poe-code 3.0.196 → 3.0.198

package/packages/superintendent/dist/document/parse.js

@@ -0,0 +1,409 @@
+import path from "node:path";
+import { parseDocument } from "yaml";
+export const superintendentDocumentSchemaId = "https://poe-platform.github.io/poe-code/schemas/plans/superintendent.schema.json";
+export const superintendentBaseDocumentSchemaId = "https://poe-platform.github.io/poe-code/schemas/plans/superintendent-base.schema.json";
+const mcpConfigSchema = {
+    type: "object",
+    properties: {
+        command: {
+            type: "string",
+            minLength: 1
+        },
+        args: {
+            type: "array",
+            items: {
+                type: "string"
+            }
+        },
+        timeout: {
+            type: "number",
+            exclusiveMinimum: 0
+        }
+    },
+    required: ["command"],
+    additionalProperties: false
+};
+const agentRoleSchema = {
+    type: "object",
+    properties: {
+        agent: {
+            type: "string",
+            minLength: 1,
+            default: "claude-code"
+        },
+        mode: {
+            type: "string",
+            minLength: 1
+        },
+        cwd: {
+            type: "string",
+            minLength: 1
+        },
+        mcp: {
+            type: "object",
+            additionalProperties: mcpConfigSchema
+        },
+        prompt: {
+            type: "string",
+            minLength: 1
+        }
+    },
+    required: ["prompt"],
+    additionalProperties: false
+};
+const partialAgentRoleSchema = {
+    type: "object",
+    properties: {
+        agent: {
+            type: "string",
+            minLength: 1,
+            default: "claude-code"
+        },
+        mode: {
+            type: "string",
+            minLength: 1
+        },
+        cwd: {
+            type: "string",
+            minLength: 1
+        },
+        mcp: {
+            type: "object",
+            additionalProperties: mcpConfigSchema
+        },
+        prompt: {
+            type: "string",
+            minLength: 1
+        }
+    },
+    additionalProperties: false
+};
+const statusSchema = {
+    type: "object",
+    properties: {
+        state: {
+            type: "string",
+            enum: ["in_progress", "review", "completed"]
+        },
+        round: {
+            type: "integer",
+            minimum: 0
+        },
+        review_turn: {
+            type: "integer",
+            minimum: 0
+        },
+        reason: {
+            type: "string",
+            minLength: 1
+        }
+    },
+    required: ["state", "round", "review_turn"],
+    additionalProperties: false
+};
+const partialStatusSchema = {
+    type: "object",
+    properties: {
+        state: {
+            type: "string",
+            enum: ["in_progress", "review", "completed"]
+        },
+        round: {
+            type: "integer",
+            minimum: 0
+        },
+        review_turn: {
+            type: "integer",
+            minimum: 0
+        },
+        reason: {
+            type: "string",
+            minLength: 1
+        }
+    },
+    additionalProperties: false
+};
+export const superintendentDocumentSchema = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: superintendentDocumentSchemaId,
+    title: "Superintendent plan document",
+    type: "object",
+    properties: {
+        $schema: {
+            type: "string",
+            const: superintendentDocumentSchemaId
+        },
+        kind: {
+            type: "string",
+            const: "superintendent"
+        },
+        version: {
+            type: "integer",
+            minimum: 1
+        },
+        mcp: {
+            type: "object",
+            additionalProperties: mcpConfigSchema
+        },
+        builder: agentRoleSchema,
+        inspectors: {
+            type: "object",
+            additionalProperties: agentRoleSchema
+        },
+        superintendent: agentRoleSchema,
+        owner: agentRoleSchema,
+        max_rounds: {
+            type: "integer",
+            minimum: 1,
+            default: 100
+        },
+        status: statusSchema
+    },
+    required: ["kind", "version", "builder", "superintendent", "owner", "status"],
+    additionalProperties: false
+};
+export const superintendentBaseDocumentSchema = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: superintendentBaseDocumentSchemaId,
+    title: "Superintendent base document",
+    type: "object",
+    properties: {
+        $schema: {
+            type: "string",
+            const: superintendentBaseDocumentSchemaId
+        },
+        kind: {
+            type: "string",
+            const: "superintendent-base"
+        },
+        version: {
+            type: "integer",
+            minimum: 1
+        },
+        mcp: {
+            type: "object",
+            additionalProperties: mcpConfigSchema
+        },
+        builder: partialAgentRoleSchema,
+        inspectors: {
+            type: "object",
+            additionalProperties: partialAgentRoleSchema
+        },
+        superintendent: partialAgentRoleSchema,
+        owner: partialAgentRoleSchema,
+        max_rounds: {
+            type: "integer",
+            minimum: 1
+        },
+        status: partialStatusSchema
+    },
+    required: ["kind"],
+    additionalProperties: false
+};
+const validStatusStates = new Set(["in_progress", "review", "completed"]);
+export function parseSuperintendentDoc(filePath, content) {
+    const resolvedFilePath = path.resolve(filePath);
+    const { frontmatterText, body } = splitFrontmatter(resolvedFilePath, content);
+    const parsedFrontmatter = parseYamlFrontmatter(resolvedFilePath, frontmatterText);
+    return {
+        filePath: resolvedFilePath,
+        body,
+        frontmatter: parseFrontmatter(resolvedFilePath, parsedFrontmatter)
+    };
+}
+export function readExplicitBuilderAgent(filePath, content) {
+    const resolvedFilePath = path.resolve(filePath);
+    const { frontmatterText } = splitFrontmatter(resolvedFilePath, content);
+    const parsedFrontmatter = parseYamlFrontmatter(resolvedFilePath, frontmatterText);
+    const frontmatter = expectRecord(parsedFrontmatter, "frontmatter", resolvedFilePath);
+    if (frontmatter.builder === undefined) {
+        return undefined;
+    }
+    const builder = expectRecord(frontmatter.builder, "builder", resolvedFilePath);
+    return builder.agent === undefined
+        ? undefined
+        : expectString(builder.agent, "builder.agent", resolvedFilePath);
+}
+function splitFrontmatter(filePath, content) {
+    const normalizedContent = content.startsWith("\uFEFF") ? content.slice(1) : content;
+    const openingLineBreak = readOpeningLineBreak(normalizedContent);
+    if (openingLineBreak === undefined) {
+        throw new Error(`${filePath}: expected YAML frontmatter delimited by ---`);
+    }
+    const frontmatterStart = 3 + openingLineBreak.length;
+    const closingFenceIndex = findClosingFence(normalizedContent, frontmatterStart, filePath);
+    const frontmatterEnd = readFrontmatterEnd(normalizedContent, closingFenceIndex);
+    return {
+        frontmatterText: normalizedContent.slice(frontmatterStart, frontmatterEnd),
+        body: readBody(normalizedContent, closingFenceIndex + 4)
+    };
+}
+function readOpeningLineBreak(content) {
+    if (!content.startsWith("---")) {
+        return undefined;
+    }
+    const nextCharacter = content[3];
+    if (nextCharacter === "\n") {
+        return "\n";
+    }
+    if (nextCharacter === "\r" && content[4] === "\n") {
+        return "\r\n";
+    }
+    return nextCharacter === undefined ? "\n" : undefined;
+}
+function findClosingFence(content, searchFrom, filePath) {
+    let currentIndex = searchFrom - 1;
+    while (currentIndex < content.length) {
+        const candidateIndex = content.indexOf("\n---", currentIndex);
+        if (candidateIndex === -1) {
+            throw new Error(`${filePath}: missing YAML frontmatter end delimiter (---)`);
+        }
+        const fenceEnd = candidateIndex + 4;
+        const nextCharacter = content[fenceEnd];
+        if (nextCharacter === "\n" || nextCharacter === undefined) {
+            return candidateIndex;
+        }
+        if (nextCharacter === "\r" && content[fenceEnd + 1] === "\n") {
+            return candidateIndex;
+        }
+        currentIndex = fenceEnd;
+    }
+    throw new Error(`${filePath}: missing YAML frontmatter end delimiter (---)`);
+}
+function readBody(content, bodyStart) {
+    const nextCharacter = content[bodyStart];
+    if (nextCharacter === "\n") {
+        return content.slice(bodyStart + 1);
+    }
+    if (nextCharacter === "\r" && content[bodyStart + 1] === "\n") {
+        return content.slice(bodyStart + 2);
+    }
+    return content.slice(bodyStart);
+}
+function readFrontmatterEnd(content, closingFenceIndex) {
+    return content[closingFenceIndex - 1] === "\r" ? closingFenceIndex - 1 : closingFenceIndex;
+}
+function parseYamlFrontmatter(filePath, frontmatterText) {
+    const document = parseDocument(frontmatterText);
+    if (document.errors.length > 0) {
+        throw new Error(`${filePath}: invalid YAML frontmatter: ${document.errors[0].message}`);
+    }
+    return document.toJSON();
+}
+function parseFrontmatter(filePath, value) {
+    const frontmatter = expectRecord(value, "frontmatter", filePath);
+    const kind = frontmatter.kind;
+    if (kind === undefined) {
+        throw new Error(`${filePath}: missing \`kind\` field in frontmatter`);
+    }
+    if (kind !== "superintendent") {
+        throw new Error(`${filePath}: frontmatter kind must be "superintendent"`);
+    }
+    return {
+        kind,
+        version: expectNumber(frontmatter.version, "version", filePath),
+        mcp: parseMcpMap(frontmatter.mcp, filePath),
+        builder: parseRequiredRole(frontmatter.builder, "builder", filePath),
+        inspectors: parseInspectorMap(frontmatter.inspectors, filePath),
+        superintendent: parseRequiredRole(frontmatter.superintendent, "superintendent", filePath),
+        owner: parseRequiredRole(frontmatter.owner, "owner", filePath),
+        max_rounds: frontmatter.max_rounds === undefined
+            ? 100
+            : expectNumber(frontmatter.max_rounds, "max_rounds", filePath),
+        status: parseStatusBlock(frontmatter.status, filePath)
+    };
+}
+function parseRequiredRole(value, roleName, filePath) {
+    if (value === undefined) {
+        throw new Error(`${filePath}: missing required role \`${roleName}\``);
+    }
+    const role = expectRecord(value, roleName, filePath);
+    const mcp = role.mcp === undefined ? undefined : parseMcpMap(role.mcp, filePath, `${roleName}.mcp`);
+    return {
+        agent: role.agent === undefined
+            ? "claude-code"
+            : expectString(role.agent, `${roleName}.agent`, filePath),
+        mode: role.mode === undefined ? undefined : expectString(role.mode, `${roleName}.mode`, filePath),
+        cwd: role.cwd === undefined ? undefined : expectString(role.cwd, `${roleName}.cwd`, filePath),
+        mcp,
+        prompt: expectString(role.prompt, `${roleName}.prompt`, filePath)
+    };
+}
+function parseInspectorMap(value, filePath) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const inspectors = expectRecord(value, "inspectors", filePath);
+    return Object.fromEntries(Object.entries(inspectors).map(([name, config]) => [
+        name,
+        parseRequiredRole(config, `inspectors.${name}`, filePath)
+    ]));
+}
+function parseMcpMap(value, filePath, fieldName = "mcp") {
+    if (value === undefined) {
+        return undefined;
+    }
+    const mcp = expectRecord(value, fieldName, filePath);
+    return Object.fromEntries(Object.entries(mcp).map(([name, config]) => [
+        name,
+        parseMcpConfig(config, `${fieldName}.${name}`, filePath)
+    ]));
+}
+function parseMcpConfig(value, fieldName, filePath) {
+    const config = expectRecord(value, fieldName, filePath);
+    return {
+        command: expectString(config.command, `${fieldName}.command`, filePath),
+        args: config.args === undefined
+            ? undefined
+            : expectStringArray(config.args, `${fieldName}.args`, filePath),
+        timeout: config.timeout === undefined
+            ? undefined
+            : expectPositiveNumber(config.timeout, `${fieldName}.timeout`, filePath)
+    };
+}
+function parseStatusBlock(value, filePath) {
+    const status = expectRecord(value, "status", filePath);
+    const state = expectString(status.state, "status.state", filePath);
+    if (!validStatusStates.has(state)) {
+        throw new Error(`${filePath}: status.state must be one of in_progress, review, completed`);
+    }
+    const parsedState = state;
+    return {
+        state: parsedState,
+        round: expectNumber(status.round, "status.round", filePath),
+        review_turn: expectNumber(status.review_turn, "status.review_turn", filePath)
+    };
+}
+function expectRecord(value, fieldName, filePath) {
+    if (!isRecord(value)) {
+        throw new Error(`${filePath}: ${fieldName} must be a mapping`);
+    }
+    return value;
+}
+function expectString(value, fieldName, filePath) {
+    if (typeof value !== "string") {
+        throw new Error(`${filePath}: ${fieldName} must be a string`);
+    }
+    return value;
+}
+function expectNumber(value, fieldName, filePath) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new Error(`${filePath}: ${fieldName} must be a number`);
+    }
+    return value;
+}
+function expectPositiveNumber(value, fieldName, filePath) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        throw new Error(`${filePath}: ${fieldName} must be a positive number`);
+    }
+    return value;
+}
+function expectStringArray(value, fieldName, filePath) {
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+        throw new Error(`${filePath}: ${fieldName} must be an array of strings`);
+    }
+    return value;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/packages/superintendent/dist/document/tasks.d.ts

@@ -0,0 +1,12 @@
+export type TaskItem = {
+    text: string;
+    done: boolean;
+};
+export type TaskBoard = {
+    tasks: TaskItem[];
+    allDone: boolean;
+    openCount: number;
+    doneCount: number;
+};
+export declare function parseTaskBoard(body: string): TaskBoard;
+export declare function hasTaskBoard(body: string): boolean;

package/packages/superintendent/dist/document/tasks.js

@@ -0,0 +1,96 @@
+import { parse } from "@poe-code/design-system";
+export function parseTaskBoard(body) {
+    const sectionNodes = readTaskBoardSection(body);
+    const tasks = [];
+    for (const node of sectionNodes) {
+        collectTasks(node, tasks);
+    }
+    const doneCount = tasks.filter((task) => task.done).length;
+    const openCount = tasks.length - doneCount;
+    return {
+        tasks,
+        allDone: openCount === 0,
+        openCount,
+        doneCount
+    };
+}
+export function hasTaskBoard(body) {
+    return findTaskBoardHeadingIndex(parseRoot(body).children) !== -1;
+}
+function readTaskBoardSection(body) {
+    const root = parseRoot(body);
+    const headingIndex = findTaskBoardHeadingIndex(root.children);
+    if (headingIndex === -1) {
+        throw new Error('Missing "## Task Board" section');
+    }
+    const sectionNodes = [];
+    for (let index = headingIndex + 1; index < root.children.length; index += 1) {
+        const node = root.children[index];
+        if (node.type === "heading" && node.depth <= 2) {
+            break;
+        }
+        sectionNodes.push(node);
+    }
+    return sectionNodes;
+}
+function parseRoot(body) {
+    const ast = parse(body).ast;
+    if (ast.type !== "root") {
+        throw new Error("Expected markdown root node");
+    }
+    return ast;
+}
+function findTaskBoardHeadingIndex(children) {
+    return children.findIndex((node) => node.type === "heading" && node.depth === 2 && extractText(node).trim() === "Task Board");
+}
+function collectTasks(node, tasks) {
+    if (node.type === "listItem" && typeof node.checked === "boolean") {
+        tasks.push({
+            text: readTaskText(node),
+            done: node.checked
+        });
+    }
+    if (!("children" in node)) {
+        return;
+    }
+    for (const child of node.children) {
+        collectTasks(child, tasks);
+    }
+}
+function readTaskText(node) {
+    let text = "";
+    for (const child of node.children) {
+        if (child.type === "list") {
+            continue;
+        }
+        const childText = extractText(child).trim();
+        if (childText.length === 0) {
+            continue;
+        }
+        text = text.length === 0 ? childText : `${text}\n${childText}`;
+    }
+    return text;
+}
+function extractText(node) {
+    switch (node.type) {
+        case "text":
+        case "inlineCode":
+        case "code":
+        case "html":
+            return node.value;
+        case "image":
+            return node.alt;
+        case "break":
+            return "\n";
+        case "footnoteReference":
+            return node.label;
+        case "thematicBreak":
+        case "frontmatter":
+            return "";
+        default:
+            if (!("children" in node)) {
+                return "";
+            }
+            return node.children.map(extractText).join("");
+    }
+}

package/packages/superintendent/dist/document/write.d.ts

@@ -0,0 +1,6 @@
+import { type StatusBlock } from "./parse.js";
+export declare function updateStatus(filePath: string, content: string, status: StatusBlock): string;
+export declare function setStatusReason(filePath: string, content: string, reason: string | undefined): string;
+export declare function incrementRound(filePath: string, content: string): string;
+export declare function setReviewTurn(filePath: string, content: string, turn: number): string;
+export declare function transitionState(filePath: string, content: string, newState: StatusBlock["state"]): string;

package/packages/superintendent/dist/document/write.js

@@ -0,0 +1,156 @@
+import path from "node:path";
+import { isMap, parseDocument } from "yaml";
+import { parseSuperintendentDoc, superintendentDocumentSchemaId } from "./parse.js";
+export function updateStatus(filePath, content, status) {
+    return updateFrontmatter(filePath, content, (frontmatterDocument) => {
+        frontmatterDocument.set("status", {
+            state: status.state,
+            round: status.round,
+            review_turn: status.review_turn
+        });
+    });
+}
+export function setStatusReason(filePath, content, reason) {
+    return updateFrontmatter(filePath, content, (frontmatterDocument) => {
+        if (reason === undefined) {
+            frontmatterDocument.deleteIn(["status", "reason"]);
+            return;
+        }
+        frontmatterDocument.setIn(["status", "reason"], reason);
+    });
+}
+function updateFrontmatter(filePath, content, mutate) {
+    const resolvedFilePath = path.resolve(filePath);
+    const parts = splitDocument(resolvedFilePath, content);
+    const frontmatterDocument = parseDocument(parts.frontmatterText);
+    if (frontmatterDocument.errors.length > 0) {
+        throw new Error(`${resolvedFilePath}: invalid YAML frontmatter: ${frontmatterDocument.errors[0].message}`);
+    }
+    mutate(frontmatterDocument);
+    canonicalizeFrontmatter(frontmatterDocument);
+    return [
+        parts.bom,
+        "---",
+        parts.lineBreak,
+        formatFrontmatter(frontmatterDocument.toString(), parts.lineBreak),
+        parts.frontmatterSuffix,
+        parts.body
+    ].join("");
+}
+function getTopLevelMap(frontmatterDocument) {
+    if (!frontmatterDocument.contents || !isMap(frontmatterDocument.contents)) {
+        throw new Error("Expected superintendent frontmatter to be a top-level object.");
+    }
+    return frontmatterDocument.contents;
+}
+function reorderTopLevelKeys(map, keys) {
+    const remaining = [...map.items];
+    const ordered = keys.flatMap((key) => {
+        const index = remaining.findIndex((item) => item.key?.toString() === key);
+        return index === -1 ? [] : remaining.splice(index, 1);
+    });
+    map.items = [...ordered, ...remaining];
+}
+function canonicalizeFrontmatter(frontmatterDocument) {
+    const map = getTopLevelMap(frontmatterDocument);
+    map.delete("maxExperiments");
+    map.delete("metricTimeout");
+    map.delete("planPath");
+    map.set("$schema", superintendentDocumentSchemaId);
+    map.set("kind", "superintendent");
+    map.set("version", 1);
+    reorderTopLevelKeys(map, ["$schema", "kind", "version"]);
+}
+export function incrementRound(filePath, content) {
+    const document = parseSuperintendentDoc(filePath, content);
+    return updateStatus(filePath, content, {
+        ...document.frontmatter.status,
+        round: document.frontmatter.status.round + 1
+    });
+}
+export function setReviewTurn(filePath, content, turn) {
+    const document = parseSuperintendentDoc(filePath, content);
+    return updateStatus(filePath, content, {
+        ...document.frontmatter.status,
+        review_turn: turn
+    });
+}
+export function transitionState(filePath, content, newState) {
+    const document = parseSuperintendentDoc(filePath, content);
+    return updateStatus(filePath, content, {
+        ...document.frontmatter.status,
+        state: newState,
+        review_turn: newState === "in_progress" ? 0 : document.frontmatter.status.review_turn
+    });
+}
+function splitDocument(filePath, content) {
+    const bom = content.startsWith("\uFEFF") ? "\uFEFF" : "";
+    const normalizedContent = bom ? content.slice(1) : content;
+    const lineBreak = readOpeningLineBreak(normalizedContent);
+    if (lineBreak === undefined) {
+        throw new Error(`${filePath}: expected YAML frontmatter delimited by ---`);
+    }
+    const frontmatterStart = 3 + lineBreak.length;
+    const closingFenceIndex = findClosingFence(normalizedContent, frontmatterStart, filePath);
+    const frontmatterEnd = readFrontmatterEnd(normalizedContent, closingFenceIndex);
+    const bodyStart = readBodyStart(normalizedContent, closingFenceIndex + 4);
+    return {
+        bom,
+        lineBreak,
+        frontmatterText: normalizedContent.slice(frontmatterStart, frontmatterEnd),
+        frontmatterSuffix: normalizedContent.slice(frontmatterEnd, bodyStart),
+        body: normalizedContent.slice(bodyStart)
+    };
+}
+function readOpeningLineBreak(content) {
+    if (!content.startsWith("---")) {
+        return undefined;
+    }
+    const nextCharacter = content[3];
+    if (nextCharacter === "\n") {
+        return "\n";
+    }
+    if (nextCharacter === "\r" && content[4] === "\n") {
+        return "\r\n";
+    }
+    return nextCharacter === undefined ? "\n" : undefined;
+}
+function findClosingFence(content, searchFrom, filePath) {
+    let currentIndex = searchFrom - 1;
+    while (currentIndex < content.length) {
+        const candidateIndex = content.indexOf("\n---", currentIndex);
+        if (candidateIndex === -1) {
+            throw new Error(`${filePath}: missing YAML frontmatter end delimiter (---)`);
+        }
+        const fenceEnd = candidateIndex + 4;
+        const nextCharacter = content[fenceEnd];
+        if (nextCharacter === "\n" || nextCharacter === undefined) {
+            return candidateIndex;
+        }
+        if (nextCharacter === "\r" && content[fenceEnd + 1] === "\n") {
+            return candidateIndex;
+        }
+        currentIndex = fenceEnd;
+    }
+    throw new Error(`${filePath}: missing YAML frontmatter end delimiter (---)`);
+}
+function readBodyStart(content, bodyStart) {
+    const nextCharacter = content[bodyStart];
+    if (nextCharacter === "\n") {
+        return bodyStart + 1;
+    }
+    if (nextCharacter === "\r" && content[bodyStart + 1] === "\n") {
+        return bodyStart + 2;
+    }
+    return bodyStart;
+}
+function readFrontmatterEnd(content, closingFenceIndex) {
+    return content[closingFenceIndex - 1] === "\r" ? closingFenceIndex - 1 : closingFenceIndex;
+}
+function formatFrontmatter(serialized, lineBreak) {
+    const normalized = serialized.endsWith("\n") ? serialized.slice(0, -1) : serialized;
+    if (lineBreak === "\n") {
+        return normalized;
+    }
+    return normalized.replaceAll("\n", lineBreak);
+}

package/packages/superintendent/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { parseSuperintendentDoc, superintendentBaseDocumentSchema, superintendentBaseDocumentSchemaId, superintendentDocumentSchema, superintendentDocumentSchemaId } from "./document/parse.js";
+export { updateStatus, transitionState, incrementRound } from "./document/write.js";
+export { parseTaskBoard, hasTaskBoard } from "./document/tasks.js";
+export type { SuperintendentDoc, SuperintendentFrontmatter, StatusBlock, TaskBoard, TaskItem } from "./document/parse.js";
+export { runLoop } from "./runtime/loop.js";
+export { runBuilder } from "./runtime/run-builder.js";
+export { runInspector, runAllInspectors } from "./runtime/run-inspector.js";
+export { resolveTemplate } from "./runtime/templates.js";
+export type { LoopCallbacks, BuilderResult, InspectorResult, TemplateContext } from "./runtime/types.js";
+export { createLoopState, applyTransition, isComplete } from "./state/machine.js";
+export { superintendentGroup } from "./commands/index.js";
+export { superintendentConfigScope } from "./config-scope.js";