Quick Reference

This page lists every frontmatter key, Lua global and member, substitution form, default and limit, and error kind in the prompt language, each linked to the chapter that teaches it. Use it to look up an exact form or value, and follow the link when you need to know how that piece behaves.

Frontmatter keys

Every frontmatter key and value rule, with top-level keys first and nested keys grouped under their parent.

Key	Value	Default	Taught in
Top-level key set	`name`, `description`, `promptforge`, `max_tool_iterations`, `input`, `output`, `plugins`, `tools`, `args`, `models`	only `name` and `description` required	Prompt File Structure
`name`	string, kept as written	none, required	Prompt File Structure
`description`	one-line string, kept as written	none, required	Prompt File Structure
`promptforge`	`0`	none, needed to run	Prompt File Structure
`max_tool_iterations`	whole number `1` to `1000`	`24` per `models.loop` call, or the Harness's default	Conversations
`input`	map of `path` and `description`	no input file	Prompt File Structure
`output`	map of `path` and `description`	no output file	Prompt File Structure
`plugins`	list of Plugin entries	no Plugins	Tools
`tools`	map of alias to tool path	no tool slots	Tools
`args`	map of arg name to arg declaration	implicit `prose` arg	Arguments
`models`	map of role label to role declaration	no model roles	Models
`args.{name}`	arg declaration map	none	Arguments
`args.{name}.default`	value matching `type`	no default	Arguments
`args.{name}.description`	string	no description	Arguments
`args.{name}.optional`	boolean	`false`	Arguments
`args.{name}.type`	`string`, `boolean`, `integer`, or `number`	none, required	Arguments
Implicit `prose` arg	optional `string` arg `prose`, described as `Freeform input for this prompt`	used when `args` is absent	Arguments
`input.description`	string	none, required	Prompt File Structure
`input.path`	store filename, such as `paper.md`	none, required	Prompt File Structure
`models.{label}`	role declaration map, `{}` for none	none	Models
`models.{label}.description`	string	the bound model's catalog description	Models
`models.{label}.keywords`	list drawn from the seven keywords, kept in order	no keywords	Models
`models.{label}.keywords` entry `chat`	soft keyword	not set	Models
`models.{label}.keywords` entry `creative`	soft keyword	not set	Models
`models.{label}.keywords` entry `fast`	soft keyword	not set	Models
`models.{label}.keywords` entry `frontier`	soft keyword	not set	Models
`models.{label}.keywords` entry `no-thinking`	hard keyword, thinking off	not set	Models
`models.{label}.keywords` entry `small`	soft keyword	not set	Models
`models.{label}.keywords` entry `thinking`	hard keyword, thinking on	not set	Models
`models.{label}.min_context`	whole number of tokens, `1` to `4294967295`	no minimum	Models
Name grammar for aliases, role labels, and arg names	`[A-Za-z][A-Za-z0-9_-]{0,63}`	none	Prompt File Structure
`output.description`	string	none, required	Prompt File Structure
`output.path`	store filename, such as `report.md`	none, required	Prompt File Structure
`plugins` entry as a string	Plugin id `namespace/plugin`, such as `promptforge/web`	required, no config	Tools
`plugins` entry `config`	any YAML value	no config	Tools
`plugins` entry `optional`	boolean	`false`	Tools
`plugins` entry `ref`	Plugin id	none, required in the map form	Tools
Reserved names for tool aliases and role labels	no Engine global, sandbox Lua global, or Lua keyword, such as `store`, `argv`, `pairs`, or `end`, and no name under both `tools` and `models`; the chapter lists every one	none	Prompt File Structure
Tool path in `tools.{alias}`	`namespace/plugin/name`, such as `promptforge/web/fetch`	none	Tools
`tools.{alias}`	tool path string	none	Tools

Lua globals and members

Every global, function, field, and record shape a prompt's Lua code can use, with its form, what it gives back, and the chapter that teaches it.

models

Name	Form	Returns	Taught in
`handle.capabilities`	`h.capabilities`	The role's keywords, a sequence of kebab-case strings in declaration order	Models
`handle.context`	`h.context`	The bound model's context window in tokens, at least 1	Models
`handle.description`	`h.description`	The role's `description:`, or the model's catalog description, which can be empty	Models
`handle.label`	`h.label`	The role label, the same string as `h.name`	Models
`handle.max_tokens`	`h.max_tokens`	The `max_tokens` option from `models.use`, or `nil`	Models
`handle.model_id`	`h.model_id`	The bound model's catalog id, such as `claude-sonnet-4-6`	Models
`handle.name`	`h.name`	The role label	Models
`handle.temperature`	`h.temperature`	The `temperature` option from `models.use`, or `nil`	Models
`handle.thinking`	`h.thinking`	`true` for `thinking`, `false` for `no-thinking`, `nil` for neither	Models
model handle	`local h = models.get('writer')`	Frozen userdata with nine read-only fields and no methods	Models
`models.default`	`models.default(label)`	The default role's model handle; sets the prompt-wide default	Models
`models.get`	`models.get(label)`	The role's model handle; the selection is unchanged	Models
`models.get`	`models.get(ui().selected_model)`	A model handle for a Host catalog model id, with a Host-state snapshot only	Models
`models.infer`	`models.infer(prompt)`	The reply as a string, from one round on the section's model	Models
`models.infer`	`models.infer(handle, prompt)`	The reply as a string, from one round on the handle's model	Models
`models.loop`	`models.loop(messages, compactor?)`	`nil`; appends every record to `messages`	Conversations
`models.loop`	`models.loop(handle, messages, compactor?)`	`nil`; every round runs on the handle's model	Conversations
`models.loop` compactor argument	`models.loop(msgs, function(reason) ... end)`	Called with `"precheck"` or `"provider"` on overflow	Conversations
`models.use`	`models.use(label)`	The role's model handle; selects the role for the section	Models
`models.use` option `max_tokens`	`{ max_tokens = n }`	Whole number from 1 to 4294967295; read back as `h.max_tokens`	Models
`models.use` option `temperature`	`{ temperature = n }`	Finite number from 0.0 to 2.0; read back as `h.temperature`	Models
`models.use` options	`models.use(label, { temperature = 0.3, max_tokens = 256 })`	A model handle carrying the options; an omitted option reads `nil`	Models

messages

Name	Form	Returns	Taught in
builder chaining	`messages.new():system(s):user(u)`	The same list, one record appended per call in call order	Conversations
content part `image_url`	`{ type = "image_url", image_url = { url = "data:image/png;base64,..." } }`	An image part in a record's `content` array	Conversations
content part `text`	`{ type = "text", text = "..." }`	A text part in a record's `content` array	Conversations
`list:append`	`list:append(record)`	The same list, with `record` appended unchanged	Conversations
`list:assistant`	`list:assistant(content, tool_calls?)`	The same list, with an `assistant` record appended	Conversations
`list:system`	`list:system(content)`	The same list, with `{ role = "system", content = content }` appended	Conversations
`list:tool`	`list:tool(content, tool_call_id)`	The same list, with a `tool` record appended	Conversations
`list:user`	`list:user(content)`	The same list, with `{ role = "user", content = content }` appended	Conversations
`messages.new`	`messages.new()`	An empty message list, length 0	Conversations
`record.content`	`record.content`	A string, or a non-empty array of content parts	Conversations
`record.role`	`record.role`	`system`, `user`, `assistant`, or `tool`	Conversations
`record.tool_call_id`	`record.tool_call_id`	On a `tool` record, the string `id` of the call it answers	Conversations
`record.tool_calls`	`record.tool_calls`	On an `assistant` record, an array of `{ id, name, arguments? }`	Conversations
tool call entry	`call.id`, `call.name`, `call.arguments`	The call id, the alias the model called, and the parsed arguments table	Conversations

compactors

Name	Form	Returns	Taught in
`compactors.fail`	`models.loop(msgs, compactors.fail)`	The default policy; an overflowing round raises `context_exhausted`	Conversations
`compactors.fail(tag)`	`compactors.fail('precheck')`	Never returns; raises `context_exhausted` with `reason` set to the tag	Conversations
overflow reason `"precheck"`	`err.reason == 'precheck'`	The request's token count plus the room kept for the reply exceeded the context window; nothing was sent	Conversations
overflow reason `"provider"`	`err.reason == 'provider'`	The provider rejected the request as too large for the context window	Conversations

tools

Name	Form	Returns	Taught in
Tool object	the alias global, such as `search`	A frozen Tool object with five fields and no methods	Tools
`Tool.description`	`search.description`	The tool's catalog description, never an override	Tools
`Tool.name`	`search.name`	The alias the slot is bound under	Tools
`Tool.parameters`	`search.parameters`	An empty table	Tools
`Tool.untrusted`	`search.untrusted`	`false`	Tools
`Tool.wire_name`	`search.wire_name`	The last segment of the tool path, such as `fetch`	Tools
`tools.add`	`tools.add(alias_or_tool)`	Nothing; scopes the tool into the current section	Tools
`tools.add` array form	`tools.add({ 'search', fetch })`	Nothing; scopes every listed tool	Tools
`tools.add` description override	`tools.add(alias, description)`	Nothing; sets the model's description for this section	Tools
`tools.add_local`	`tools.add_local(alias, description, params, handler)`	Nothing; registers a local tool in the section	Tools
`tools.add_local` handler args	`function(a) return a.text end`	One fresh table of the call's arguments, by declared name	Tools
`tools.add_local` handler return	`return 'saved'`	A scalar, as the call's text; `nil` gives the empty string	Tools
`tools.add_local` param types	`"string"`, `"integer"`, `"number"`, `"boolean"`	The parameter's JSON Schema type	Tools
`tools.add_local` params table	`{ query = 'string', limit = { 'integer', 'maximum hits' } }`	JSON Schema `object` parameters, every one required	Tools
`tools.allow_tasks`	`tools.allow_tasks()`	Nothing; scopes the task built-ins, allowing any section the chain can resolve	Tasks
`tools.allow_tasks` targets list	`tools.allow_tasks({ '## Summarize', '## Review' })`	Nothing; scopes the task built-ins and limits the model's `task` calls to the listed headings	Tasks
`tools.always`	`tools.always(alias)`	Nothing; scopes the tool into every section	Tools
`tools.always` description override	`tools.always(alias, description)`	Nothing; sets the model's description for the whole run	Tools
`tools.call`	`tools.call(alias_or_tool, args?)`	The tool's output: a string, or a table from a structured tool	Tools
`tools.calls`	`tools.calls[alias]` or `tools.calls.alias`	The section's call count for that alias, an integer	Tools

store

Name	Form	Returns	Taught in
`store.append`	`store.append(path, contents)`	`nil`; adds `contents` to the end, creating the file when absent	The Store
`store.delete`	`store.delete(path)`	`nil`; removes the file or an empty directory, and succeeds when absent	The Store
`store.exists`	`store.exists(path)`	`true` or `false`, for a file or a directory	The Store
`store.glob`	`store.glob(pattern)`	A sorted array of matching store file paths, or only directories for a pattern ending in `/`	The Store
`store.read`	`store.read(path)`	The whole file verbatim as a string	The Store
`store.read` with a range	`store.read(path, start, end?)`	Lines `start` to `end`, 1-based and inclusive, joined with `"\n"`	The Store
`store.read_numbered`	`store.read_numbered(path)`	The whole file as `N\| text` lines numbered from 1	The Store
`store.read_numbered` with a range	`store.read_numbered(path, start, end?)`	The selected lines with their absolute line numbers	The Store
`store.str_replace`	`store.str_replace(path, old, new)`	`nil`; replaces the single occurrence of `old` with `new`	The Store
`store.write`	`store.write(path, contents)`	`nil`; creates the file or replaces its text	The Store

tasks

Name	Form	Returns	Taught in
Task handle	`{ task = id }`	A plain methodless table; the bare id string also works	Tasks
`tasks.cancel`	`tasks.cancel(task)`	Nothing; cancelling an ended task does nothing	Tasks
`tasks.note`	`tasks.note(text)`	Nothing; sets the `note` field of `tasks.status`	Tasks
`tasks.pending`	`tasks.pending(filter?)`	The chain's live Task handles in spawn order, empty when none	Tasks
`tasks.pending` filter `origin`	`tasks.pending({ origin = 'model' })`	Only live tasks of that origin, `author` or `model`	Tasks
`tasks.ready`	`tasks.ready(task)`	`true` once the task has ended, else `false`	Tasks
`tasks.spawn`	`tasks.spawn(target, opts?)`	A Task handle, at once	Tasks
`tasks.spawn` option `index`	`{ index = n }`	The task's `sys.index`, an integer of 0 or more	Tasks
`tasks.spawn` option `input`	`{ input = s }`	A string that replaces the task's `args`	Tasks
`tasks.spawn` option `item`	`{ item = v }`	JSON data that becomes the task's `item`	Tasks
`tasks.status`	`tasks.status(task)`	The status table of an owned task or of `sys.taskid`	Tasks
`tasks.status` fields	`tasks.status(t).state`	`target`, `origin`, `state`, `ok`, `section`, `blocked`, `turns`, `tasks`, `depth`, `note`	Tasks
`tasks.concurrency`	`tasks.concurrency(n?)`	The chain's effective admission limit, lowered by `n`, clamped to the parent's	Tasks
`tasks.join`	`tasks.join(set, opts?)`	A results sequence in set order, then `timed_out`	Tasks
`tasks.join` result entry	`results[i]`	`{ task, ok, result }`, itself a Task handle	Tasks
`tasks.join` `timed_out`	`local results, timed_out = tasks.join(set, { timeout = 5 })`	`true` when the timeout expired first, else `false`	Tasks
`tasks.join_any`	`tasks.join_any(set, opts?)`	The ended member's Task handle, `ok`, and its result text or error value	Tasks
`tasks.join_any` with a timeout	`tasks.join_any(set, { timeout = 5 })`	`nil` when no member ended in time	Tasks
wait option `timeout`	`{ timeout = seconds }`	A whole, fractional, or zero number of seconds	Tasks

sys

Name	Form	Returns	Taught in
`sys.execution`	`sys.execution`	The run's name, assigned by the Harness	The Lua Environment
`sys.id`	`sys.id`	The current section entry's id, such as `0.3.0`	The Lua Environment
`sys.index`	`sys.index`	An arm's 1-based position in its collection, or a task's `index` option	Fanout
`sys.model`	`sys.model`	The section's catalog model id, readable only after the section's first tool call	Models
`sys.section_count`	`sys.section_count`	The number of top-level sections in the prompt	The Lua Environment
`sys.section_name`	`sys.section_name`	The running section's heading name, or the title in the H1 pass	The Lua Environment
`sys.taskid`	`sys.taskid`	The nearest enclosing task's id, `0` on the main walk	The Lua Environment
`sys.when`	`sys.when`	The run's start instant as an RFC 3339 string	The Lua Environment

Model-facing task tools

For each tool and argument, Form is what the model sends and Returns is the text the model gets back; the tools.allow_tasks row is the Lua call that puts these tools in scope.

Name	Form	Returns	Taught in
`await_tasks`	`{}`	Every task notice that has arrived, one per line, once one of the model's tasks ends; `nothing to wait for` when none is running	Tasks
`await_tasks.timeout`	`{"timeout": 0.1}`	Any notices, then `timed out; tasks {ids} still running` when no task ended in time; `slept {seconds} seconds` when none is running	Tasks
`task`	`{"target": "## Research"}`	`Task id={id} started`, at once	Tasks
`task.input`	`"input": "text"`, optional	Replaces the task's argument string	Tasks
`task.target`	`"target": "## Research"`, required	Names the section the task runs	Tasks
`task_cancel`	`{"id": "0.0"}`	`Task id={task} cancelled`	Tasks
`task_cancel.id`	`"id": "0.0"`, required	Names a task the model started, exactly as `task` returned it	Tasks
`task_status`	`{"id": "0.0"}`	One line starting `Task id={task} (## {target}): {state}`	Tasks
`task_status.id`	`"id": "0.0"`, required	Names a task the model started, exactly as `task` returned it	Tasks
`tools.allow_tasks`	`tools.allow_tasks(targets?)` in Lua	`task`, `task_cancel`, `task_status`, and `await_tasks` in scope for every round in the section	Tasks

Web tools

For each tool and argument, Form is what the model sends and Returns is the text the model gets back; the promptforge/web row is the Plugin line that makes the tools available.

Name	Form	Returns	Taught in
`promptforge/web`	`plugins: [promptforge/web]`	The tool paths `promptforge/web/fetch` and `promptforge/web/search`	Web Fetch and Search
`promptforge/web/fetch`	`{"url": "https://example.com/"}`	A `url:`, `truncated:`, `extraction:` header, a blank line, then the content, in the untrusted envelope	Web Fetch and Search
`promptforge/web/fetch` `max_chars`	`"max_chars": 5000`, optional	At most that many characters, 1 to the policy's limit (40,000 by default); the limit when omitted	Web Fetch and Search
`promptforge/web/fetch` `raw`	`"raw": true`, optional	The whole HTML page as markdown, with `extraction: raw-html`; `false` when omitted	Web Fetch and Search
`promptforge/web/fetch` `url`	`"url": "https://example.com/"`, required	The page at that address	Web Fetch and Search
`promptforge/web/search`	`{"query": "rust async runtime"}`	JSON text with a `results` array, in the untrusted envelope	Web Fetch and Search
`promptforge/web/search` `count`	`"count": 5`, optional	At most that many results, 1 to 20; the gateway's default when omitted	Web Fetch and Search
`promptforge/web/search` `country`	`"country": "us"`, optional	One country's results; 1 to 128 characters, not blank	Web Fetch and Search
`promptforge/web/search` `exclude_domains`	`"exclude_domains": ["example.com"]`, optional	Drops results from those sites; at most 20 bare hostnames	Web Fetch and Search
`promptforge/web/search` `freshness`	`"freshness": "pw"`, optional	Results from the past day, week, month, or year: `pd`, `pw`, `pm`, or `py`	Web Fetch and Search
`promptforge/web/search` `include_domains`	`"include_domains": ["example.com"]`, optional	Only results from those sites; at most 20 bare hostnames	Web Fetch and Search
`promptforge/web/search` `query`	`"query": "rust async runtime"`, required	The search text; 1 to 400 characters, not blank	Web Fetch and Search
`promptforge/web/search` `safesearch`	`"safesearch": "strict"`, optional	The SafeSearch level: `off`, `moderate`, or `strict`	Web Fetch and Search
`promptforge/web/search` `search_lang`	`"search_lang": "en"`, optional	The search language; 1 to 128 characters, not blank	Web Fetch and Search

Operator input

The promptforge/user-input row is the Plugin line that defines the rest. The two input rows are Lua calls, and the ask tool row is what a model sends when the prompt lets it ask.

Name	Form	Returns	Taught in
`promptforge/user-input`	`plugins: [promptforge/user-input]`	The `input` global and the tool path `promptforge/user-input/ask`; required, the run is refused when the Host has nobody to ask	The Lua Environment
`input.ask`	`local text, available = input.ask()` in Lua	the operator's next message and `true`, or the fixed fallback sentence and `false`	The Lua Environment
`input.connected`	`input.connected()` in Lua	`true` when the Host has someone to ask; fixed for the whole run	The Lua Environment
`promptforge/user-input/ask`	`{}`	The operator's next message, trusted; offered to a model only through a `tools:` alias	The Lua Environment

Lua standard library

Every section VM runs Lua 5.5 with these libraries and base functions.

Name	Form	Returns	Taught in
`_G`	`_G`	the global table	The Lua Environment
`_VERSION`	`_VERSION`	the Lua version string	The Lua Environment
`assert`	`assert(condition, message)`	raises `message` when `condition` is false	The Lua Environment
`error`	`error(message)`	raises `message`	The Lua Environment
`getmetatable`	`getmetatable(v)`	as in standard Lua 5.5; `var` and `sys` give a guard string, and `_G` gives the metatable you set or nil	The Lua Environment
`ipairs`	`ipairs(t)`	as in standard Lua 5.5	The Lua Environment
`math` library	`math.{name}(...)`	as in standard Lua 5.5	The Lua Environment
`select`	`select(n, ...)`	as in standard Lua 5.5	The Lua Environment
`setmetatable`	`setmetatable(t, mt)`	`t`; on `_G`, `mt` composes behind the `argv` and `prose` guard	The Lua Environment
`string` library	`string.upper(s)`, `s:match(pattern)`	as in standard Lua 5.5	The Lua Environment
`table` library	`table.{name}(...)`	as in standard Lua 5.5	The Lua Environment
`table.concat`	`table.concat(list, sep, i, j)`	joined string; `__tostring` values render with `tostring`	The Lua Environment
`tonumber`	`tonumber(v)`	as in standard Lua 5.5	The Lua Environment
`tostring`	`tostring(v)`	string; an error value gives its message	The Lua Environment
`type`	`type(v)`	type name; an error value gives `'table'`	The Lua Environment

Other globals

These globals, fanout result fields, and error value fields need no declaration.

Name	Form	Returns	Taught in
`{alias}`	`{alias}`	Tool object for that bound tool slot; never a reserved name	Tools
`args`	`args`	the raw argument string	Arguments
`argv`	`argv`	the parsed argument string; `{ prose = args }` without `args:`, nil when structured input is not JSON	Arguments
`call`	`call(target, input?)`	the called chain's result as a string	Jump and Call
`compactors`	`compactors.fail`	the `compactors` namespace	Conversations
`err .. s` and `s .. err`	`'prefix: ' .. err`	concatenation with the error's message	The Lua Environment
`err.finish_reason`	`err.finish_reason`	provider finish reason on `empty_model_reply`, when sent	Conversations
`err.kind` and `err.message`	`local ok, err = pcall(f, ...)`	error kind tag; message string	The Lua Environment
`err.kind` tags	`err.kind == '{tag}'`	one of exactly thirteen tags	The Lua Environment
`err.name`	`err.name`	requested tool name on `unbound_tool` and `out_of_scope_tool`	Tools
`err.reason`	`err.reason`	`precheck` or `provider` on `context_exhausted`; a store reason such as `not_found`, `invalid_path`, or `anchor` on `store`	Conversations
`err.task`	`err.task`	task id on `task_not_owned`, `task_consumed`, and a cancelled task	Tasks
`err.tasks`	`err.tasks`	leaked task ids joined with `,` in spawn order, on `tasks_live`	Tasks
`fanout`	`fanout(worker, collection)`	array of fanout results, one per member in collection order	Fanout
heading reference	`'## Name'`	the section with that level and name	Jump and Call
Engine globals	no import	installed in every section VM	The Lua Environment
`item`	`item`	the arm's member inside a fanout arm, or a task's `item` option	Fanout
`item.key` and `item.value`	`item.key`, `item.value`	a keyed member's key and value	Fanout
`jump`	`jump(target)`	nothing; ends the block and the walk continues at `target`	Jump and Call
`{label}`	`{label}`	model handle for that bound role; never a reserved name	Models
`list_from_section`	`list_from_section(heading)`	1-based array of the list section's item strings	Blocks and Prose
`log`	`log(message)`	nothing; records a `lua` checkpoint event	The Lua Environment
`messages`	`messages.new()`	the `messages` namespace	Conversations
`models`	`models.{name}(...)`	the `models` namespace	Models
`next`	`next(t, k?)`	next key and value in `pairs` order; `nil, nil` past the last key	The Lua Environment
`pairs`	`pairs(t)`	iteration in the same fixed key order on every run	The Lua Environment
`pcall`	`pcall(f, ...)`	`true` and results, or `false` and an error value or the value you raised	The Lua Environment
`prose`	`prose`	the block's pending prose, rendered, as a string	Blocks and Prose
`result.exhausted`	`r[i].exhausted`	`true` only when the arm's `models.loop` hit the round cap	Fanout
`result.item`	`r[i].item`	the member the arm processed	Fanout
`result.ok`	`r[i].ok`	`true` when the arm completed normally, `false` at the round cap	Fanout
`result.text`	`r[i].text`	the arm's result text, `''` when it returned none	Fanout
`store`	`store.{name}(...)`	the `store` namespace	The Store
`sys`	`sys.{field}`	the `sys` namespace	The Lua Environment
`tasks`	`tasks.{name}(...)`	the `tasks` namespace	Tasks
`tools`	`tools.{name}(...)`	the `tools` namespace	Tools
`tostring(err)`	`tostring(err)`	the error's message, with no traceback	The Lua Environment
`tostring(result)` and `table.concat(results)`	`tostring(r[i])`, `table.concat(r, sep)`	the result's text; the joined texts	Fanout
`ui`	`ui()`	Host-state snapshot table; present only when the Host supplies one	The Lua Environment
`untrusted`	`untrusted(s)`	`s` inside an untrusted envelope	The Store
`var`	`var.key = value`	your own values, carried along the walk	The Lua Environment
`xpcall`	`xpcall(f, handler, ...)`	like `pcall`; `handler` receives the error value	The Lua Environment

Substitution forms

Each row links to the section that teaches the form.

Form	Renders	Taught in
Inserted text	Verbatim, never scanned again	Substitution
Resolved value	Strings as is, numbers and booleans in natural form, tables and arrays as compact JSON with sorted keys	Substitution
`\{{`, `\}}`, `\\`	`{{`, `}}`, `\`	Substitution
`{{ args }}`	The argument string exactly as passed	Substitution
`{{ argv }}`	The whole parsed arguments	Substitution
`{{ argv.key }}`	One field of the parsed arguments, at any depth	Substitution
`{{ item }}`	The seeded item of a fanout arm or a task, by its type, JSON null as `null`	Substitution
`{{ name }}`	A section-local Lua global, whole	Substitution
`{{ name.key }}`	A field of a table held in a Lua global	Substitution
`{{ path }}`	The value its first segment names: `args`, `argv`, `item`, `var`, `sys`, or a Lua global	Substitution
`{{ sys.key }}`	A runtime-provided `sys` field	Substitution
`{{ var.key }}`	A value in `var`, with dotted paths for nested fields	Substitution

Defaults and limits

Set by names the frontmatter key that sets a value, or says whether the Harness sets it or it is fixed.

Name	Default	Range or rule	Set by	Taught in
Call depth cap	8 levels	Nested `call`, fanout arms, and tasks share it, first call included	fixed	Jump and Call
Cancel poll interval	10,000 instructions	A Host cancel stops a running block within this many instructions	fixed	Limits and Errors
Concurrency limit	8 tasks at once	Every task the run admits, fanout arms included; `tasks.concurrency` lowers it for a chain's own spawns	Harness	Fanout
Generic completion text	`done`	The run result when no block returns a scalar	fixed	How a Prompt Runs
Harness-set limits	Listed in the chapter	A prompt changes only the round cap	Harness	Limits and Errors
Instruction count	No cap	Only the cancel poll counts instructions	fixed	Limits and Errors
Log byte quota	262,144 bytes per section VM	256 UTF-8 bytes per allowed log event, so it follows the log event quota	Harness	Limits and Errors
Log event quota	1024 `log` calls per section VM	Every one-argument `log` call spends one	Harness	Limits and Errors
Log message length	256 characters	Counted as Unicode characters	fixed	The Lua Environment
Lua memory	64 MiB per section VM	Running out is an ordinary `lua` error	Harness	Limits and Errors
Model receive timeout	120 seconds	Applies to the headers and to each next body chunk	Harness	Limits and Errors
Model response cap	16 MiB	A larger reply fails the call	Harness	Limits and Errors
Round cap default	24 rounds	Per `models.loop` call, when `max_tool_iterations` is absent	Harness	Conversations
Round cap from frontmatter	The Harness default	Whole number 1 to 1000, per `models.loop` call	`max_tool_iterations`	Conversations
Run limit defaults	Listed in the chapter	One set applies to the whole run	Harness	Limits and Errors
`input.ask` fallback sentence	`User input is unavailable in this host; continue without it.`	Returned with `available` set to `false` when the Host has nobody to ask	fixed	The Lua Environment

Error kinds

Parse error kinds classify a file that fails to parse, run error kinds classify how a failed run ended, and error kinds on error values are the kind tags a pcall sees.

Parse error kinds

Kind	Raised when	Message names	Taught in
`Fence`	A second `lua shared` fence, a `lua shared` fence outside the H1, or an unclosed fence	The unclosed fence's label or section name, else nothing	Limits and Errors
`Frontmatter`	The frontmatter block is missing, unclosed, or not valid YAML, or a frontmatter key or value is rejected	The YAML diagnostic, in `invalid frontmatter: {message}`, or the rejected key's own message, with the line and column beside it	Limits and Errors
`List`	A list section holds non-list content, an empty item, or no items	The section name, and the offending line for non-list content	Limits and Errors
`Lua`	A Lua region (the shared library, an H1 block, or a section block) does not compile	The section and block, plus the compiler diagnostic	Limits and Errors
`Structure`	The H1 title is missing, repeated, or empty, a heading is empty or has no parent one level up, two siblings share a name, or the file has no `promptforge:` key when run	The section name, the heading level, and both lines of a duplicate sibling	Limits and Errors

Run error kinds

Kind	Raised when	Message names	Taught in
`Binding`	A section sends prose to a model or calls `models.infer` without a handle while no `models.use` or `models.default` is in effect	The section, in `model binding required for section {section}`	Limits and Errors
Cancelled outcome	The Host cancels the run, or a caught `cancelled` error value is raised again after another suspending call; a clean stop with no run error kind, not a failure	Nothing; the outcome carries no message	Limits and Errors
`Completion`	A model call fails at the transport, backend, or decode layer (a disabled gateway included), or an empty reply, and the error goes uncaught	The failure's fixed phrase, with the backend status when there is one	Limits and Errors
`ContextExhausted`	A round overflows the model's context window under the selected compactor and goes uncaught	The reason, in `context exhausted: {reason}`	Limits and Errors
`Determinism`	Two accesses unordered by happens-before touch one store region in conflicting ways; the call never returns, so no `pcall` catches it, not even during a shared library load	The store path, both chains, and both claim kinds, in `store determinism violation: {detail}`	Limits and Errors
`Internal`	An Engine invariant breaks, a fault in the Engine rather than the prompt	The invariant, in `internal invariant violated: {message}`	Limits and Errors
`Lua`	An uncaught Lua failure in a walked section, `call` chain, task, fanout arm, or the shared library load, including a failed substitution, running out of memory, and a block that returns a table; a task error in any chain; a caught `lua`, `internal`, `out_of_scope_tool`, `unbound_tool`, or task error value raised again after another suspending call	The Lua error's own text	Limits and Errors
`Parse`	The file fails with any parse error kind, or has no `promptforge:` key	The parse error's own message, with its location beside it when known	Limits and Errors
`Quota`	The log event quota or the log byte quota runs out and the error goes uncaught	Nothing, as in `lua log event quota exceeded` or `lua log byte quota exceeded`	Limits and Errors
`RequirementsUnmet`	Prepare finds a required Plugin missing, two declared Plugins in conflict, or a model role requirement unmet, or an ordinary Lua error goes uncaught in the H1 pass	Each unmet requirement on its own line, or the Lua error text	Limits and Errors
Retryable failures	`Completion` failures from a transport failure (a receive timeout included), a malformed or oversized reply, a rate limit or an overloaded backend, or a backend status of 500 or higher; nothing reruns a failed run automatically	The backend status, when there is one	Limits and Errors
`Vfs`	An uncaught `store` failure, a caught one raised again, a run whose handle declares no store, or the Host's store backend failing outside any store call	The store failure's own text, as in `file not found in store: {path}` or `store operation failed`	Limits and Errors
`Tool`	A tool fails, the model calls a tool outside the round's scope, a script calls an alias not bound in the run, or `models.loop` reaches its round cap, and the error goes uncaught	The tool's failure text, the requested name and the aliases in scope or bound, or nothing, as in `tool-call loop did not converge`	Limits and Errors
`Version`	The `promptforge:` key declares a major version other than `0`	The declared version, in `unsupported promptforge version: {n} (this build supports major 0)`	Limits and Errors

Error kinds on error values

Kind	Raised when	Message names	Taught in
`cancelled`	A Host cancel reaches running Lua or a waiting call, or a wait returns it, unraised, for a cancelled task	Nothing, as in `interrupted by Ctrl-C`, or the task, in task `{task}` was cancelled; field `task`	Limits and Errors
`context_exhausted`	A `models.loop` round overflows the context window under `compactors.fail`, or a script calls `compactors.fail(tag)`	The reason in words, in `context exhausted: {reason}`; field `reason` is `"precheck"` or `"provider"`	Conversations
`empty_model_reply`	A `models.loop` reply is empty and is not the clean exit	The message `the model replied with no text and no tool calls`; field `finish_reason` when the provider sent one	Conversations
`internal`	A failure outside the prompt: a model call's transport, backend, or decode failure, a disabled gateway, the missing-model error, or an Engine fault	The failure's fixed phrase with the backend status when there is one, or the section, depending on the failure	Limits and Errors
`lua`	A runtime error, an Engine call's argument or misuse error, running out of memory, a spent log quota, or a failed substitution	The error's own text, such as the unknown field or the store path	Limits and Errors
`store`	A store call fails, except a claims conflict, which ends the run as `Determinism` without raising	The store's message, as in `file not found in store: {path}`; field `reason`, plus `path`, and `anchor` and `count` or `rule`	The Store
`out_of_scope_tool`	The model calls a name outside the round's scope	The requested name and the aliases in scope, in `tool "{name}" is not in this section's scope; in-scope aliases: [...]`; field `name`	Tools
`task_consumed`	A wait names a task already delivered	The task, in task `{task}` was already delivered: a task's result is taken by one wait; field `task`	Tasks
`task_not_owned`	A wait, status read, or cancel names a task the chain does not own, or an id that names no task	The task, in task `{task}` is not a task this chain owns; field `task`	Tasks
`tasks_live`	A chain ends normally with tasks it spawned still live	The leaked ids in spawn order; field `tasks`, joined with `,`	Tasks
`tool`	A bound tool fails in a script `tools.call`	The tool's model-safe failure text, in `tool call failure: {message}`	Tools
`tool_loop_exhausted`	`models.loop` makes its round cap of rounds without a final reply	Nothing, as in `tool-call loop did not converge`	Conversations
`unbound_tool`	A script `tools.call` names neither a local tool nor an alias bound in the run, or names a task built-in	The name and every bound alias, in `tool "{name}" is not bound in this run; bound aliases: [...]`; field `name`	Tools

PromptForge Language Guide