poe-code 3.0.196 → 3.0.198

package/packages/superintendent/dist/runtime/run-inspector.js

@@ -0,0 +1,119 @@
+import { spawn } from "@poe-code/agent-spawn";
+import { resolveRoleCwd } from "./resolve-cwd.js";
+import { buildInspectorSystemPrompt, prependSystemPrompt } from "./system-prompt.js";
+import { resolveTemplate } from "./templates.js";
+export async function runInspector(name, config, doc, context, options) {
+    const userPrompt = options.promptOverride ??
+        resolveTemplate(config.prompt, buildTemplateContext(doc, context));
+    const systemPrompt = buildInspectorSystemPrompt({
+        inspectorName: name,
+        ...(context.builder
+            ? {
+                builder: {
+                    summary: context.builder.summary,
+                    ...(context.builder.log_path ? { log_path: context.builder.log_path } : {})
+                }
+            }
+            : {})
+    });
+    const prompt = prependSystemPrompt(systemPrompt, userPrompt);
+    const output = await runAutonomous({
+        agent: config.agent,
+        mode: config.mode,
+        prompt,
+        cwd: resolveRoleCwd(config, doc.filePath, options.defaultCwd),
+        mcpServers: buildMcpServers(doc, config),
+        ...(options.logPath ? { logPath: options.logPath } : {})
+    });
+    const logPath = extractLogPath(output);
+    return {
+        name,
+        summary: extractSummary(output),
+        ...(logPath ? { log_path: logPath } : {})
+    };
+}
+function buildMcpServers(doc, config) {
+    const merged = {
+        ...(doc.frontmatter.mcp ?? {}),
+        ...(config.mcp ?? {})
+    };
+    if (Object.keys(merged).length === 0) {
+        return undefined;
+    }
+    const servers = {};
+    for (const [name, mcpConfig] of Object.entries(merged)) {
+        servers[name] = {
+            command: mcpConfig.command,
+            ...(mcpConfig.args ? { args: [...mcpConfig.args] } : {}),
+            ...(mcpConfig.timeout !== undefined ? { timeout: mcpConfig.timeout } : {})
+        };
+    }
+    return servers;
+}
+export async function runAllInspectors(doc, context, options) {
+    const inspectors = doc.frontmatter.inspectors;
+    if (inspectors === undefined) {
+        return [];
+    }
+    const inspectorSummaries = { ...(context.inspectors ?? {}) };
+    const results = [];
+    for (const [name, config] of Object.entries(inspectors)) {
+        const result = await runInspector(name, config, doc, {
+            ...context,
+            inspectors: inspectorSummaries
+        }, options);
+        results.push(result);
+        inspectorSummaries[name] = result.summary;
+    }
+    return results;
+}
+function buildTemplateContext(doc, context) {
+    return {
+        ...context,
+        plan: {
+            ...(context.plan ?? { path: doc.filePath }),
+            path: doc.filePath
+        }
+    };
+}
+async function runAutonomous(input) {
+    const spawnApi = spawn;
+    if (typeof spawnApi.autonomous === "function") {
+        return spawnApi.autonomous(input.agent, {
+            cwd: input.cwd,
+            prompt: input.prompt,
+            mode: input.mode,
+            ...(input.mcpServers ? { mcpServers: input.mcpServers } : {}),
+            ...(input.logPath ? { logPath: input.logPath } : {})
+        });
+    }
+    const result = await spawn(input.agent, {
+        cwd: input.cwd,
+        prompt: input.prompt,
+        mode: input.mode,
+        ...(input.mcpServers ? { mcpServers: input.mcpServers } : {}),
+        ...(input.logPath ? { logPath: input.logPath } : {})
+    });
+    return {
+        stdout: result.stdout,
+        ...(result.logFile ? { logFile: result.logFile } : {})
+    };
+}
+function extractLogPath(result) {
+    if (typeof result === "string")
+        return undefined;
+    return typeof result.logFile === "string" ? result.logFile : undefined;
+}
+function extractSummary(result) {
+    if (typeof result === "string") {
+        return result;
+    }
+    return (readString(result.summary) ??
+        readString(result.output) ??
+        readString(result.stdout) ??
+        readString(result.text) ??
+        "");
+}
+function readString(value) {
+    return typeof value === "string" ? value : undefined;
+}

package/packages/superintendent/dist/runtime/run-owner-review.d.ts

@@ -0,0 +1,18 @@
+import type { SuperintendentDoc } from "../document/parse.js";
+import { type TemplateContext } from "./templates.js";
+import { type WorkflowTransition } from "./workflow-tool.js";
+type OwnerTransition = Extract<WorkflowTransition, {
+    action: "approve_completion";
+} | {
+    action: "request_changes";
+}>;
+export type OwnerResult = {
+    transition: OwnerTransition;
+    log_path?: string;
+};
+export type RunOwnerReviewOptions = {
+    defaultCwd: string;
+    logPath?: string;
+};
+export declare function runOwnerReview(doc: SuperintendentDoc, context: Partial<TemplateContext>, options: RunOwnerReviewOptions): Promise<OwnerResult>;
+export {};

package/packages/superintendent/dist/runtime/run-owner-review.js

@@ -0,0 +1,208 @@
+import { spawn } from "@poe-code/agent-spawn";
+import { resolveRoleCwd } from "./resolve-cwd.js";
+import { buildOwnerSystemPrompt, prependSystemPrompt } from "./system-prompt.js";
+import { resolveTemplate } from "./templates.js";
+import { createWorkflowTool, parseWorkflowCall } from "./workflow-tool.js";
+const WORKFLOW_SERVER_NAME = "owner-workflow";
+const WORKFLOW_SERVER_COMMAND = "poe-superintendent-mcp";
+const WORKFLOW_SERVER_SUBCOMMAND = "workflow-transition";
+const WORKFLOW_SERVER_TIMEOUT_SECONDS = 7200;
+export async function runOwnerReview(doc, context, options) {
+    const userPrompt = resolveTemplate(doc.frontmatter.owner.prompt, buildTemplateContext(doc, context));
+    const prompt = prependSystemPrompt(buildOwnerSystemPrompt(), userPrompt);
+    const result = await runAutonomous({
+        agent: doc.frontmatter.owner.agent,
+        mode: doc.frontmatter.owner.mode,
+        prompt,
+        cwd: resolveRoleCwd(doc.frontmatter.owner, doc.filePath, options.defaultCwd),
+        mcpServers: buildMcpServers(doc),
+        ...(options.logPath ? { logPath: options.logPath } : {})
+    });
+    const logPath = extractLogPath(result);
+    return {
+        transition: extractOwnerTransition(result),
+        ...(logPath ? { log_path: logPath } : {})
+    };
+}
+function buildTemplateContext(doc, context) {
+    return { ...context, plan: { path: doc.filePath } };
+}
+function buildMcpServers(doc) {
+    const servers = {
+        [WORKFLOW_SERVER_NAME]: createWorkflowServer()
+    };
+    const merged = {
+        ...(doc.frontmatter.mcp ?? {}),
+        ...(doc.frontmatter.owner.mcp ?? {})
+    };
+    for (const [name, config] of Object.entries(merged)) {
+        servers[name] = toSpawnMcpServer(config);
+    }
+    return servers;
+}
+function createWorkflowServer() {
+    const workflowTool = createWorkflowTool("owner", "review");
+    return {
+        command: WORKFLOW_SERVER_COMMAND,
+        args: [WORKFLOW_SERVER_SUBCOMMAND, encodeJson(workflowTool)],
+        timeout: WORKFLOW_SERVER_TIMEOUT_SECONDS
+    };
+}
+function toSpawnMcpServer(config) {
+    return {
+        command: config.command,
+        ...(config.args ? { args: [...config.args] } : {}),
+        ...(config.timeout !== undefined ? { timeout: config.timeout } : {})
+    };
+}
+async function runAutonomous(input) {
+    const spawnApi = spawn;
+    if (typeof spawnApi.autonomous === "function") {
+        return spawnApi.autonomous(input.agent, {
+            cwd: input.cwd,
+            prompt: input.prompt,
+            mode: input.mode,
+            ...(input.mcpServers ? { mcpServers: input.mcpServers } : {}),
+            ...(input.logPath ? { logPath: input.logPath } : {})
+        });
+    }
+    const result = await spawn(input.agent, {
+        cwd: input.cwd,
+        prompt: input.prompt,
+        mode: input.mode,
+        ...(input.mcpServers ? { mcpServers: input.mcpServers } : {}),
+        ...(input.logPath ? { logPath: input.logPath } : {})
+    });
+    return {
+        stdout: result.stdout,
+        ...(result.logFile ? { logFile: result.logFile } : {})
+    };
+}
+function extractLogPath(result) {
+    if (typeof result === "string")
+        return undefined;
+    return typeof result.logFile === "string" ? result.logFile : undefined;
+}
+function extractOwnerTransition(result) {
+    const transition = extractTransition(result);
+    if (transition === undefined) {
+        throw new Error(`Owner review must end with workflow_transition.${describeMissingTransition(result)}`);
+    }
+    if (transition.action !== "approve_completion" && transition.action !== "request_changes") {
+        throw new Error(`Owner review returned invalid transition: ${transition.action}`);
+    }
+    return transition;
+}
+function describeMissingTransition(result) {
+    const parts = [];
+    const names = collectToolNames(result);
+    parts.push(names.length === 0 ? " No tool calls were captured." : ` Observed tool calls: ${names.join(", ")}.`);
+    const logPath = extractLogPath(result);
+    if (logPath) {
+        parts.push(` See spawn log: ${logPath}`);
+    }
+    return parts.join("");
+}
+function collectToolNames(result) {
+    if (typeof result === "string") {
+        return [];
+    }
+    const names = [];
+    collectToolNamesFrom(result.toolCalls, names);
+    if (isRecord(result.sessionResult)) {
+        collectToolNamesFrom(result.sessionResult.toolCalls, names);
+    }
+    return names;
+}
+function collectToolNamesFrom(value, out) {
+    if (!Array.isArray(value)) {
+        return;
+    }
+    for (const entry of value) {
+        const toolCall = readToolCall(entry);
+        const name = toolCall ? readToolCallName(toolCall) : undefined;
+        if (name) {
+            out.push(name);
+        }
+    }
+}
+function extractTransition(result) {
+    if (typeof result === "string") {
+        return undefined;
+    }
+    const toolCallTransition = readTransitionFromToolCalls(result.toolCalls);
+    if (toolCallTransition) {
+        return toolCallTransition;
+    }
+    return readTransitionFromSessionResult(result.sessionResult);
+}
+function readTransitionFromToolCalls(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    for (const entry of value) {
+        const toolCall = readToolCall(entry);
+        if (!toolCall || !isWorkflowToolName(readToolCallName(toolCall))) {
+            continue;
+        }
+        const argumentsValue = readToolCallArguments(toolCall);
+        if (argumentsValue === undefined) {
+            continue;
+        }
+        return parseWorkflowCall(parseJsonValue(argumentsValue));
+    }
+    return undefined;
+}
+function readTransitionFromSessionResult(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return readTransitionFromToolCalls(value.toolCalls);
+}
+function readToolCall(value) {
+    return isRecord(value) ? value : undefined;
+}
+function readToolCallName(toolCall) {
+    return (readString(toolCall.name) ??
+        readString(toolCall.tool) ??
+        readString(toolCall.title) ??
+        readString(toolCall.path));
+}
+function readToolCallArguments(toolCall) {
+    return toolCall.arguments ?? toolCall.args ?? toolCall.input;
+}
+function isWorkflowToolName(name) {
+    if (!name)
+        return false;
+    if (name === "workflow_transition")
+        return true;
+    return name.startsWith("mcp__") && name.endsWith("__workflow_transition");
+}
+function parseJsonValue(value) {
+    if (typeof value !== "string") {
+        return value;
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        return value;
+    }
+    const parsed = tryParseJson(trimmed);
+    return parsed === undefined ? value : parsed;
+}
+function tryParseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function encodeJson(value) {
+    return Buffer.from(JSON.stringify(value), "utf8").toString("base64");
+}
+function readString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/packages/superintendent/dist/runtime/run-superintendent.d.ts

@@ -0,0 +1,13 @@
+import type { SuperintendentDoc } from "../document/parse.js";
+import { type TemplateContext } from "./templates.js";
+import { type WorkflowTransition } from "./workflow-tool.js";
+export type SuperintendentResult = {
+    summary: string;
+    transition?: WorkflowTransition;
+    log_path?: string;
+};
+export type RunSuperintendentOptions = {
+    defaultCwd: string;
+    logPath?: string;
+};
+export declare function runSuperintendent(doc: SuperintendentDoc, context: Partial<TemplateContext>, options: RunSuperintendentOptions): Promise<SuperintendentResult>;

package/packages/superintendent/dist/runtime/run-superintendent.js

@@ -0,0 +1,208 @@
+import { spawn } from "@poe-code/agent-spawn";
+import { resolveRoleCwd } from "./resolve-cwd.js";
+import { buildSuperintendentSystemPrompt, prependSystemPrompt } from "./system-prompt.js";
+import { resolveTemplate } from "./templates.js";
+import { parseWorkflowCall } from "./workflow-tool.js";
+const SUPERINTENDENT_TOOLS_SERVER_NAME = "superintendent-tools";
+const SUPERINTENDENT_TOOLS_SERVER_COMMAND = "poe-superintendent-mcp";
+const SUPERINTENDENT_TOOLS_SERVER_SUBCOMMAND = "superintendent-tools";
+const SUPERINTENDENT_TOOLS_TIMEOUT_SECONDS = 7200;
+export async function runSuperintendent(doc, context, options) {
+    const userPrompt = resolveTemplate(doc.frontmatter.superintendent.prompt, buildTemplateContext(doc, context));
+    const systemPrompt = buildSuperintendentSystemPrompt({
+        state: doc.frontmatter.status.state,
+        inspectorNames: Object.keys(doc.frontmatter.inspectors ?? {})
+    });
+    const prompt = prependSystemPrompt(systemPrompt, userPrompt);
+    const result = await runAutonomous({
+        agent: doc.frontmatter.superintendent.agent,
+        mode: doc.frontmatter.superintendent.mode,
+        prompt,
+        cwd: resolveRoleCwd(doc.frontmatter.superintendent, doc.filePath, options.defaultCwd),
+        mcpServers: buildMcpServers(doc),
+        ...(options.logPath ? { logPath: options.logPath } : {})
+    });
+    const transition = extractTransition(result);
+    const logPath = extractLogPath(result);
+    return {
+        summary: extractSummary(result, transition),
+        ...(transition ? { transition } : {}),
+        ...(logPath ? { log_path: logPath } : {})
+    };
+}
+function buildTemplateContext(doc, context) {
+    return {
+        ...context,
+        plan: {
+            ...(context.plan ?? { path: doc.filePath }),
+            path: doc.filePath
+        }
+    };
+}
+function buildMcpServers(doc) {
+    const servers = {
+        [SUPERINTENDENT_TOOLS_SERVER_NAME]: createSuperintendentToolsServer(doc)
+    };
+    const merged = {
+        ...(doc.frontmatter.mcp ?? {}),
+        ...(doc.frontmatter.superintendent.mcp ?? {})
+    };
+    for (const [name, config] of Object.entries(merged)) {
+        servers[name] = toSpawnMcpServer(config);
+    }
+    return servers;
+}
+function createSuperintendentToolsServer(doc) {
+    const payload = {
+        docPath: doc.filePath,
+        state: doc.frontmatter.status.state,
+        inspectorNames: Object.keys(doc.frontmatter.inspectors ?? {})
+    };
+    return {
+        command: SUPERINTENDENT_TOOLS_SERVER_COMMAND,
+        args: [SUPERINTENDENT_TOOLS_SERVER_SUBCOMMAND, encodeJson(payload)],
+        timeout: SUPERINTENDENT_TOOLS_TIMEOUT_SECONDS
+    };
+}
+function toSpawnMcpServer(config) {
+    return {
+        command: config.command,
+        ...(config.args ? { args: [...config.args] } : {}),
+        ...(config.timeout !== undefined ? { timeout: config.timeout } : {})
+    };
+}
+async function runAutonomous(input) {
+    const spawnApi = spawn;
+    if (typeof spawnApi.autonomous === "function") {
+        return spawnApi.autonomous(input.agent, {
+            cwd: input.cwd,
+            prompt: input.prompt,
+            mode: input.mode,
+            ...(input.mcpServers ? { mcpServers: input.mcpServers } : {}),
+            ...(input.logPath ? { logPath: input.logPath } : {})
+        });
+    }
+    const result = await spawn(input.agent, {
+        cwd: input.cwd,
+        prompt: input.prompt,
+        mode: input.mode,
+        ...(input.mcpServers ? { mcpServers: input.mcpServers } : {}),
+        ...(input.logPath ? { logPath: input.logPath } : {})
+    });
+    return {
+        stdout: result.stdout,
+        ...(result.logFile ? { logFile: result.logFile } : {})
+    };
+}
+function extractLogPath(result) {
+    if (typeof result === "string")
+        return undefined;
+    return typeof result.logFile === "string" ? result.logFile : undefined;
+}
+function extractTransition(result) {
+    if (typeof result === "string") {
+        return undefined;
+    }
+    const toolCallTransition = readTransitionFromToolCalls(result.toolCalls);
+    if (toolCallTransition) {
+        return toolCallTransition;
+    }
+    return readTransitionFromSessionResult(result.sessionResult);
+}
+function readTransitionFromToolCalls(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    for (const entry of value) {
+        const toolCall = readToolCall(entry);
+        if (!toolCall || !isWorkflowToolName(readToolCallName(toolCall))) {
+            continue;
+        }
+        const argumentsValue = readToolCallArguments(toolCall);
+        if (argumentsValue === undefined) {
+            continue;
+        }
+        return parseWorkflowCall(parseJsonValue(argumentsValue));
+    }
+    return undefined;
+}
+function readTransitionFromSessionResult(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return readTransitionFromToolCalls(value.toolCalls);
+}
+function extractSummary(result, transition) {
+    if (typeof result !== "string") {
+        const explicitSummary = readString(result.summary)?.trim();
+        if (explicitSummary) {
+            return explicitSummary;
+        }
+    }
+    if (transition?.action === "request_review") {
+        return transition.summary;
+    }
+    const firstNonEmptyLine = splitLines(extractOutputText(result))
+        .map((line) => line.trim())
+        .find((line) => line.length > 0);
+    return firstNonEmptyLine ?? "Superintendent completed without output.";
+}
+function extractOutputText(result) {
+    if (typeof result === "string") {
+        return result;
+    }
+    return (readString(result.output) ??
+        readString(result.stdout) ??
+        readString(result.text) ??
+        "");
+}
+function readToolCall(value) {
+    return isRecord(value) ? value : undefined;
+}
+function readToolCallName(toolCall) {
+    return (readString(toolCall.name) ??
+        readString(toolCall.tool) ??
+        readString(toolCall.title) ??
+        readString(toolCall.path));
+}
+function readToolCallArguments(toolCall) {
+    return toolCall.arguments ?? toolCall.args ?? toolCall.input;
+}
+function isWorkflowToolName(name) {
+    if (!name)
+        return false;
+    if (name === "workflow_transition")
+        return true;
+    return name.startsWith("mcp__") && name.endsWith("__workflow_transition");
+}
+function parseJsonValue(value) {
+    if (typeof value !== "string") {
+        return value;
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        return value;
+    }
+    const parsed = tryParseJson(trimmed);
+    return parsed === undefined ? value : parsed;
+}
+function tryParseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function encodeJson(value) {
+    return Buffer.from(JSON.stringify(value), "utf8").toString("base64");
+}
+function splitLines(value) {
+    return value.split("\n").map((line) => (line.endsWith("\r") ? line.slice(0, -1) : line));
+}
+function readString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/packages/superintendent/dist/runtime/system-prompt.d.ts

@@ -0,0 +1,17 @@
+import type { StatusBlock } from "../document/parse.js";
+type SuperintendentSystemPromptInput = {
+    state: StatusBlock["state"];
+    inspectorNames: string[];
+};
+export declare function buildSuperintendentSystemPrompt(input: SuperintendentSystemPromptInput): string;
+type InspectorSystemPromptInput = {
+    inspectorName: string;
+    builder?: {
+        summary: string;
+        log_path?: string;
+    };
+};
+export declare function buildInspectorSystemPrompt(input: InspectorSystemPromptInput): string;
+export declare function buildOwnerSystemPrompt(): string;
+export declare function prependSystemPrompt(systemPrompt: string, userPrompt: string): string;
+export {};

package/packages/superintendent/dist/runtime/system-prompt.js

@@ -0,0 +1,54 @@
+export function buildSuperintendentSystemPrompt(input) {
+    const sections = [
+        "# System",
+        "",
+        "You operate inside an autonomous build-inspect-review loop. The runtime advances only when you invoke MCP tools — narrative text is NOT observed. A decision is only recorded when you call the corresponding tool.",
+        "",
+        "## `workflow_transition` — control flow (required when work is ready)",
+        "",
+        "Invoke the `workflow_transition` MCP tool to hand off to the owner:",
+        "",
+        '- arguments: `{ "action": "request_review", "summary": "<why the work is ready>" }`',
+        "",
+        "Without this tool call, the loop starts another builder round. Do not narrate readiness — always invoke the tool.",
+        "",
+        "## `builder_run` — spawn the builder mid-round (optional)",
+        "",
+        "Invoke the `builder_run` MCP tool to run the builder with a custom prompt without waiting for the next auto-run round:",
+        "",
+        '- arguments: `{ "prompt": "<full builder prompt>" }`',
+        "",
+        "The prompt replaces the configured `builder.prompt` template for this call only."
+    ];
+    if (input.inspectorNames.length > 0) {
+        sections.push("", "## `inspector_run` — re-run an inspector mid-round (optional)", "", "Invoke the `inspector_run` MCP tool to re-run a specific inspector (e.g. to verify a fix):", "", `- arguments: \`{ "name": "<inspector-name>", "prompt"?: "<override>" }\` — available inspectors: ${input.inspectorNames.join(", ")}.`);
+    }
+    return sections.join("\n");
+}
+export function buildInspectorSystemPrompt(input) {
+    const sections = [
+        "# System",
+        "",
+        `You are the \`${input.inspectorName}\` inspector. Review the most recent builder round; scope your review to the change reported below — do not wander into unrelated areas of the repo.`
+    ];
+    if (input.builder) {
+        sections.push("", "## Builder summary", "", input.builder.summary || "(builder produced no summary)");
+        if (input.builder.log_path) {
+            sections.push("", "## Builder replay log", "", `Replay the builder's tool calls with: \`npm run replay -- ${input.builder.log_path}\``);
+        }
+    }
+    return sections.join("\n");
+}
+export function buildOwnerSystemPrompt() {
+    return [
+        "# System",
+        "",
+        "You are the owner reviewing the superintendent's work. The runtime advances only when you invoke MCP tools — narrative text is NOT observed. You MUST end your turn by invoking the `workflow_transition` MCP tool:",
+        "",
+        '- arguments: `{ "action": "approve_completion" }` — accept the work. Ends the loop.',
+        '- arguments: `{ "action": "request_changes", "feedback": "<what needs to change>" }` — send the work back; the loop continues with a new builder round.'
+    ].join("\n");
+}
+export function prependSystemPrompt(systemPrompt, userPrompt) {
+    return systemPrompt + "\n\n# Task\n\n" + userPrompt;
+}

package/packages/superintendent/dist/runtime/templates.d.ts

@@ -0,0 +1,22 @@
+export type TemplateContext = {
+    plan: {
+        path: string;
+    };
+    builder: {
+        summary: string;
+        log: string;
+        log_path: string;
+    };
+    inspectors: Record<string, string>;
+    inspector_logs: Record<string, string>;
+    superintendent: {
+        summary: string;
+        log_path?: string;
+    };
+    owner: {
+        feedback: string;
+        log_path?: string;
+    };
+};
+export declare function resolveTemplate(template: string, context: Partial<TemplateContext>): string;
+export declare function collectReferencedInspectors(template: string): Set<string>;

package/packages/superintendent/dist/runtime/templates.js

@@ -0,0 +1,23 @@
+const templateVariablePattern = /{{\s*([A-Za-z0-9_.-]+)\s*}}/g;
+const inspectorReferencePattern = /{{\s*inspectors\.([A-Za-z0-9_-]+)\s*}}/g;
+export function resolveTemplate(template, context) {
+    return template.replace(templateVariablePattern, (_match, variablePath) => {
+        const value = readTemplateValue(context, variablePath);
+        return typeof value === "string" ? value : "";
+    });
+}
+export function collectReferencedInspectors(template) {
+    const names = new Set();
+    for (const match of template.matchAll(inspectorReferencePattern)) {
+        names.add(match[1]);
+    }
+    return names;
+}
+function readTemplateValue(context, variablePath) {
+    return variablePath
+        .split(".")
+        .reduce((value, segment) => (isRecord(value) ? value[segment] : undefined), context);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/packages/superintendent/dist/runtime/types.d.ts

@@ -0,0 +1,4 @@
+export type { LoopCallbacks } from "./loop.js";
+export type { BuilderResult } from "./run-builder.js";
+export type { InspectorResult } from "./run-inspector.js";
+export type { TemplateContext } from "./templates.js";