@llm4ts/shell 2.11.0 → 2.13.0

package/kits/soap-ace/flows/lib/soap/Yaml.js

@@ -0,0 +1,309 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+export class YamlError extends Schema.TaggedError()("YamlError", {
+    line: Schema.Int,
+    detail: Schema.String
+}) {
+    get message() {
+        return `line ${this.line}: ${this.detail}`;
+    }
+}
+export const isYamlMap = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+export const isYamlList = (value) => Array.isArray(value);
+/** Remove a trailing comment that is outside quotes. */
+const stripComment = (text) => {
+    let quote;
+    for (let index = 0; index < text.length; index++) {
+        const char = text[index];
+        if (quote !== undefined) {
+            if (char === "\\" && quote === '"')
+                index++;
+            else if (char === quote)
+                quote = undefined;
+        }
+        else if (char === '"' || char === "'") {
+            // A quote opens a quoted scalar only where a value starts (after a key,
+            // a list dash, or a flow bracket), never inside a plain value (5 'ft).
+            const before = text.slice(0, index).trimEnd();
+            if (before === "" || /(^|\s)-$|[:[{,]$/.test(before))
+                quote = char;
+        }
+        else if (char === "#" && (index === 0 || /\s/.test(text[index - 1] ?? ""))) {
+            return text.slice(0, index).trimEnd();
+        }
+    }
+    return text.trimEnd();
+};
+class Reader {
+    index = 0;
+    lines;
+    raw;
+    constructor(source) {
+        this.raw = source.replace(/^\uFEFF/, "").split(/\r?\n/);
+        const lines = [];
+        for (const [position, rawLine] of this.raw.entries()) {
+            if (/^\s*\t/.test(rawLine) && rawLine.trim() !== "") {
+                throw new YamlError({ line: position + 1, detail: "tabs are not allowed for indentation" });
+            }
+            if (rawLine.trim() === "---" || rawLine.trim() === "...")
+                continue;
+            const text = stripComment(rawLine);
+            if (text.trim() === "")
+                continue;
+            lines.push({
+                number: position + 1,
+                indent: text.length - text.trimStart().length,
+                text: text.trim()
+            });
+        }
+        this.lines = lines;
+    }
+    fail(line, detail) {
+        throw new YamlError({ line, detail });
+    }
+    document() {
+        const first = this.lines[0];
+        if (first === undefined)
+            return null;
+        const value = this.block(first.indent);
+        const rest = this.lines[this.index];
+        if (rest !== undefined)
+            this.fail(rest.number, "unexpected content (check indentation)");
+        return value;
+    }
+    block(indent) {
+        const line = this.lines[this.index];
+        if (line === undefined)
+            return null;
+        return line.text === "-" || line.text.startsWith("- ")
+            ? this.sequence(indent)
+            : this.mapping(indent);
+    }
+    sequence(indent) {
+        const items = [];
+        for (;;) {
+            const line = this.lines[this.index];
+            if (line === undefined || line.indent < indent)
+                return items;
+            if (line.indent > indent)
+                this.fail(line.number, "unexpected indentation");
+            if (!(line.text === "-" || line.text.startsWith("- ")))
+                return items;
+            const rest = line.text === "-" ? "" : line.text.slice(2).trim();
+            if (rest === "-" || rest.startsWith("- ")) {
+                // `- - a`: a list item that is itself a list, starting on this line.
+                const nestedIndent = indent + (line.text.length - rest.length);
+                this.lines[this.index] = { number: line.number, indent: nestedIndent, text: rest };
+                items.push(this.sequence(nestedIndent));
+                continue;
+            }
+            this.index++;
+            if (rest === "") {
+                const next = this.lines[this.index];
+                items.push(next !== undefined && next.indent > indent ? this.block(next.indent) : null);
+            }
+            else if (this.isMappingStart(rest)) {
+                // `- key: value` opens a mapping whose further keys sit two columns in.
+                const itemIndent = indent + (line.text.length - rest.length);
+                items.push(this.mapping(itemIndent, { text: rest, number: line.number }));
+            }
+            else {
+                items.push(this.scalar(rest, line.number, indent));
+            }
+        }
+    }
+    isMappingStart(text) {
+        return this.splitKey(text) !== undefined;
+    }
+    splitKey(text) {
+        if (text.startsWith('"') || text.startsWith("'")) {
+            const quote = text[0] ?? '"';
+            let end = 1;
+            while (end < text.length) {
+                if (text[end] === "\\" && quote === '"')
+                    end += 2;
+                else if (text[end] === quote && quote === "'" && text[end + 1] === "'")
+                    end += 2;
+                else if (text[end] === quote)
+                    break;
+                else
+                    end++;
+            }
+            const after = text.slice(end + 1);
+            if (!/^\s*:(\s|$)/.test(after))
+                return undefined;
+            return {
+                key: this.quoted(text.slice(0, end + 1), 0),
+                rest: after.replace(/^\s*:/, "").trim()
+            };
+        }
+        const match = /^([^\s:#][^:#]*?|[^\s:#]):(\s+|$)(.*)$/.exec(text);
+        if (match === null)
+            return undefined;
+        return { key: (match[1] ?? "").trim(), rest: match[3] ?? "" };
+    }
+    mapping(indent, first) {
+        const entries = {};
+        const add = (text, number, lineIndent) => {
+            const split = this.splitKey(text);
+            if (split === undefined)
+                this.fail(number, `expected "key: value", found ${JSON.stringify(text)}`);
+            if (Object.hasOwn(entries, split.key))
+                this.fail(number, `duplicate key ${split.key}`);
+            if (split.rest === "") {
+                const next = this.lines[this.index];
+                entries[split.key] =
+                    next !== undefined &&
+                        (next.indent > lineIndent ||
+                            (next.indent === lineIndent && (next.text === "-" || next.text.startsWith("- "))))
+                        ? this.block(next.indent)
+                        : null;
+            }
+            else {
+                entries[split.key] = this.scalar(split.rest, number, lineIndent);
+            }
+        };
+        if (first !== undefined)
+            add(first.text, first.number, indent);
+        for (;;) {
+            const line = this.lines[this.index];
+            if (line === undefined || line.indent < indent)
+                return entries;
+            if (line.indent > indent)
+                this.fail(line.number, "unexpected indentation");
+            if (line.text === "-" || line.text.startsWith("- "))
+                return entries;
+            this.index++;
+            add(line.text, line.number, indent);
+        }
+    }
+    scalar(text, number, indent) {
+        if (text === "~" || text === "null" || text === "Null" || text === "NULL")
+            return null;
+        if (text === "[]")
+            return [];
+        if (text === "{}")
+            return {};
+        if (text.startsWith('"') || text.startsWith("'"))
+            return this.quoted(text, number);
+        if (text === "|" || text === ">" || /^[|>][-+]?$/.test(text))
+            return this.blockScalar(text, indent, number);
+        if (/^[[{&*!%@`]/.test(text)) {
+            this.fail(number, `unsupported YAML construct at ${JSON.stringify(text.slice(0, 12))}`);
+        }
+        return text;
+    }
+    quoted(text, number) {
+        const quote = text[0];
+        if (text.length < 2 || text[text.length - 1] !== quote) {
+            this.fail(number, "unterminated quoted scalar");
+        }
+        const body = text.slice(1, -1);
+        if (quote === "'")
+            return body.replace(/''/g, "'");
+        return body.replace(/\\(u[0-9A-Fa-f]{4}|.)/g, (_, escape) => {
+            if (escape.startsWith("u"))
+                return String.fromCharCode(Number.parseInt(escape.slice(1), 16));
+            const map = {
+                n: "\n",
+                t: "\t",
+                r: "\r",
+                b: "\b",
+                f: "\f",
+                '"': '"',
+                "\\": "\\",
+                "/": "/",
+                "0": "\0"
+            };
+            const value = map[escape];
+            if (value === undefined)
+                this.fail(number, `unknown escape \\${escape}`);
+            return value;
+        });
+    }
+    blockScalar(header, indent, headerLine) {
+        const folded = header.startsWith(">");
+        const keep = header.endsWith("+");
+        const strip = header.endsWith("-");
+        // Block scalar content keeps its comments and blank lines, so it is read
+        // from the raw source rather than the comment-stripped lines.
+        // Content starts on the raw line after the header, even when that line
+        // looks like a comment (# heading); its indentation is the first
+        // non-blank line's.
+        let rawIndex = headerLine;
+        const firstContent = this.raw.slice(rawIndex).find((raw) => raw.trim() !== "");
+        const contentIndent = firstContent === undefined ? 0 : firstContent.length - firstContent.trimStart().length;
+        if (firstContent === undefined || contentIndent <= indent)
+            return "";
+        const collected = [];
+        while (rawIndex < this.raw.length) {
+            const raw = this.raw[rawIndex] ?? "";
+            const rawIndent = raw.length - raw.trimStart().length;
+            if (raw.trim() !== "" && rawIndent < contentIndent)
+                break;
+            collected.push(raw.slice(contentIndent));
+            rawIndex++;
+        }
+        while (this.lines[this.index] !== undefined &&
+            (this.lines[this.index]?.number ?? 0) <= rawIndex) {
+            this.index++;
+        }
+        while (collected.length > 0 && collected[collected.length - 1]?.trim() === "")
+            collected.pop();
+        const text = folded
+            ? collected.join("\n").replace(/([^\n])\n(?=[^\n])/g, "$1 ")
+            : collected.join("\n");
+        return strip ? text : keep ? `${text}\n` : `${text}\n`;
+    }
+}
+export const parseYaml = (source) => Effect.try({
+    try: () => new Reader(source).document(),
+    catch: (cause) => cause instanceof YamlError ? cause : new YamlError({ line: 0, detail: "unreadable YAML" })
+});
+// ---------------------------------------------------------------------------
+// Writing
+const plainUnsafe = /^[-?:,[\]{}#&*!|>'"%@`\s]|[\s]$|:$|: |\s#|^(~|null|Null|NULL)$|[\n\r\t]/;
+/** A scalar as YAML: plain when it reads back unchanged, otherwise double-quoted. */
+export const yamlScalar = (value) => {
+    if (value === null)
+        return "~";
+    if (value !== "" &&
+        !plainUnsafe.test(value) &&
+        ![...value].some((char) => char.charCodeAt(0) < 32))
+        return value;
+    return JSON.stringify(value);
+};
+export const yamlKey = (key) => /^[A-Za-z_@][A-Za-z0-9_.\-@#]*$/.test(key) ? key : JSON.stringify(key);
+/** Serialize a value (no comments); mappings keep insertion order. */
+export const renderYaml = (value, indent = 0) => {
+    const pad = " ".repeat(indent);
+    if (value === null || typeof value === "string")
+        return `${pad}${yamlScalar(value)}\n`;
+    if (isYamlList(value)) {
+        if (value.length === 0)
+            return `${pad}[]\n`;
+        return value
+            .map((item) => {
+            if (item === null || typeof item === "string")
+                return `${pad}- ${yamlScalar(item)}\n`;
+            const nested = renderYaml(item, indent + 2);
+            return `${pad}- ${nested.slice(indent + 2)}`;
+        })
+            .join("");
+    }
+    const entries = Object.entries(value);
+    if (entries.length === 0)
+        return `${pad}{}\n`;
+    return entries
+        .map(([key, item]) => {
+        if (item === null || typeof item === "string") {
+            return `${pad}${yamlKey(key)}: ${yamlScalar(item)}\n`;
+        }
+        if ((isYamlList(item) && item.length === 0) ||
+            (isYamlMap(item) && Object.keys(item).length === 0)) {
+            return `${pad}${yamlKey(key)}: ${isYamlList(item) ? "[]" : "{}"}\n`;
+        }
+        return `${pad}${yamlKey(key)}:\n${renderYaml(item, isYamlList(item) ? indent : indent + 2)}`;
+    })
+        .join("");
+};

package/kits/soap-ace/flows/soap-design.js

@@ -0,0 +1,167 @@
+// Turn SOAP evidence into a REST design: analysis of masked samples, the 1:1 mapping, an evidence-citing design proposal, its check, and the projected OpenAPI 3.1 contract.
+//
+// Runs after soap-sample, rooted at the same repository. The task text is a
+// command:
+//
+//   llm4ts run soap-design --repo . "analyse [operation]"  analysis/<op>.md + .json from the exchanges
+//   llm4ts run soap-design --repo . mapping                design/mapping.json + .md, the 1:1 base
+//   llm4ts run soap-design --repo . design                 the reasoning seat drafts design/api-design.md
+//   llm4ts run soap-design --repo . revise                 redraft against the check's findings
+//   llm4ts run soap-design --repo . check                  the deterministic design review
+//   llm4ts run soap-design --repo . openapi                design/openapi.yaml from an approved design
+//
+// The design is a typed overlay on the mapping: endpoints name their SOAP
+// operations, models bind to XSD types, properties cite XSD paths, errors
+// cite outcome codes and faults (see the kit README). `check` verifies
+// coverage of every operation, verbs against the confirmed classes in
+// operations.md, the style guide (packs/ace12-rest/api-style.md), every source path, enum maps
+// against declared and observed values, and that every business error the
+// samples showed is mapped. api-design.md is the approval file: editing its
+// JSON block is the review, `Status: approved` the sign-off; an existing
+// file is never overwritten by `design`. openapi refuses a design that is
+// not approved or has check errors. LLM4TS_REASONER picks the seat that
+// drafts (default claude); LLM4TS_SOAP_SERVICE picks the service.
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import * as Effect from "effect/Effect";
+import { FlowAborted, Info, makeNodeWorkspace, mock, resolveFlowInput, runFlowMain, runNode, ScriptUsage } from "@llm4ts/runner";
+import { coderFor } from "@llm4ts/runner/Connectors";
+import { analysisPaths, writeAnalyses } from "./lib/soap/Analysis.js";
+import { operationByName } from "./lib/soap/Catalog.js";
+import { blockingIssues, checkDesign, designPaths, parseDesignFile, renderDesignFile } from "./lib/soap/Design.js";
+import { proposeDesign, reviseDesign } from "./lib/soap/DesignProposal.js";
+import { loadCatalog, loadOperationsFile, readIfPresent, serviceDirectory } from "./lib/soap/Discover.js";
+import { encodeMapping, mapService, renderMapping } from "./lib/soap/Mapping.js";
+import { projectOpenApi, renderTypedYaml } from "./lib/soap/OpenApi.js";
+const usage = 'usage: soap-design "analyse [operation] | mapping | design | revise | check | openapi"';
+const styleGuide = () => Effect.tryPromise({
+    try: () => readFile(fileURLToPath(new URL("../packs/ace12-rest/api-style.md", import.meta.url)), "utf8"),
+    catch: () => FlowAborted.make({ message: "cannot read the kit's packs/ace12-rest/api-style.md" })
+});
+const program = Effect.gen(function* () {
+    const input = yield* resolveFlowInput("analyse");
+    const [command = "analyse", ...args] = input.prompt.trim().split(/\s+/);
+    const environment = process.env;
+    const drafting = command === "design" || command === "revise";
+    const reasoner = drafting
+        ? coderFor((environment.LLM4TS_REASONER ?? "claude").trim() || "claude")
+        : undefined;
+    if (drafting && reasoner === undefined) {
+        return yield* ScriptUsage.make({
+            message: `unknown LLM4TS_REASONER '${environment.LLM4TS_REASONER ?? ""}'`
+        });
+    }
+    yield* runNode({
+        workDir: input.workDir,
+        workspace: input.workspace,
+        userPrompt: input.prompt,
+        coder: mock,
+        ...(reasoner === undefined ? {} : { reasoning: reasoner }),
+        environment
+    }, (context) => Effect.gen(function* () {
+        const say = (message) => context.events.publish(Info.make({ message }));
+        const workspace = yield* makeNodeWorkspace(input.workDir);
+        const requested = environment.LLM4TS_SOAP_SERVICE?.trim();
+        const services = (yield* workspace.discover(".llm4ts/soap/*/catalog.json")).map((path) => path.split("/")[2] ?? "");
+        const service = requested !== undefined && requested !== ""
+            ? requested
+            : services.length === 1
+                ? services[0]
+                : undefined;
+        if (service === undefined) {
+            return yield* FlowAborted.make({
+                message: services.length === 0
+                    ? "no discovered service here; run soap-discover first"
+                    : `several services (${services.join(", ")}); set LLM4TS_SOAP_SERVICE`
+            });
+        }
+        const catalog = yield* loadCatalog(workspace, service);
+        const operations = yield* loadOperationsFile(workspace, service);
+        const paths = designPaths(serviceDirectory(service));
+        const mapping = mapService(catalog);
+        const allAnalyses = () => writeAnalyses(workspace, catalog, service);
+        const report = (issues) => Effect.forEach(issues, (issue) => say(`  ${issue.severity} ${issue.where}: ${issue.detail}`), { discard: true });
+        switch (command) {
+            case "analyse":
+            case "analyze": {
+                const names = args.length === 0 ? catalog.operations.map((operation) => operation.name) : args;
+                for (const name of names) {
+                    if (operationByName(catalog, name) === undefined)
+                        return yield* FlowAborted.make({ message: `unknown operation ${name}` });
+                }
+                for (const analysis of yield* writeAnalyses(workspace, catalog, service, names)) {
+                    yield* say(`${analysis.operation}: ${analysis.exchanges} exchanges, ${analysis.outcomes.length} outcome codes, ${analysis.faults.length} faults, ${analysis.findings.length} schema findings, ${analysis.observations.length} observations → ${analysisPaths(service, analysis.operation).markdown}`);
+                }
+                return;
+            }
+            case "mapping": {
+                yield* workspace.write(paths.mapping, encodeMapping(mapping));
+                yield* workspace.write(paths.mappingSummary, renderMapping(mapping));
+                yield* say(`wrote ${paths.mapping} and ${paths.mappingSummary}`);
+                return;
+            }
+            case "design":
+            case "revise": {
+                const existing = yield* readIfPresent(workspace, paths.design);
+                if (command === "design" && existing !== undefined) {
+                    return yield* FlowAborted.make({
+                        message: `${paths.design} exists; edit it, run "check", or "revise" to redraft it`
+                    });
+                }
+                if (command === "revise" && existing === undefined) {
+                    return yield* FlowAborted.make({
+                        message: `no ${paths.design} yet; run "design" first`
+                    });
+                }
+                const analyses = yield* allAnalyses();
+                const style = yield* styleGuide();
+                yield* workspace.write(paths.mapping, encodeMapping(mapping));
+                yield* workspace.write(paths.mappingSummary, renderMapping(mapping));
+                const base = { catalog, operations, mapping, analyses, style };
+                const draft = existing === undefined
+                    ? yield* proposeDesign(context.reasoning, base)
+                    : yield* Effect.flatMap(parseDesignFile(existing), (file) => reviseDesign(context.reasoning, {
+                        ...base,
+                        current: file.design,
+                        issues: checkDesign(file.design, { catalog, operations, analyses })
+                    }));
+                const issues = checkDesign(draft, { catalog, operations, analyses });
+                yield* workspace.write(paths.design, renderDesignFile(draft, issues, "proposed"));
+                yield* say(`wrote ${paths.design}: ${draft.endpoints.length} endpoints, ${draft.models.length} models, ${blockingIssues(issues).length} errors, ${issues.length - blockingIssues(issues).length} warnings`);
+                yield* report(issues);
+                return;
+            }
+            case "check":
+            case "openapi": {
+                const text = yield* readIfPresent(workspace, paths.design);
+                if (text === undefined)
+                    return yield* FlowAborted.make({
+                        message: `no ${paths.design} yet; run "design" first`
+                    });
+                const file = yield* parseDesignFile(text);
+                const analyses = yield* allAnalyses();
+                const issues = checkDesign(file.design, { catalog, operations, analyses });
+                const errors = blockingIssues(issues);
+                yield* workspace.write(paths.design, renderDesignFile(file.design, issues, file.approved ? "approved" : "proposed"));
+                yield* say(`${paths.design}: ${file.approved ? "approved" : "proposed"}, ${errors.length} errors, ${issues.length - errors.length} warnings`);
+                yield* report(issues);
+                if (command === "check")
+                    return;
+                if (!file.approved)
+                    return yield* FlowAborted.make({
+                        message: "the design is not approved; set Status: approved after review"
+                    });
+                if (errors.length > 0)
+                    return yield* FlowAborted.make({
+                        message: `the design has ${errors.length} check errors; fix them first`
+                    });
+                yield* workspace.write(paths.openapi, renderTypedYaml(projectOpenApi(file.design)));
+                yield* say(`wrote ${paths.openapi} (projected; do not edit)`);
+                return;
+            }
+            default:
+                return yield* FlowAborted.make({ message: `unknown command ${command}\n${usage}` });
+        }
+    }));
+});
+runFlowMain(program);

package/kits/soap-ace/flows/soap-discover.js

@@ -0,0 +1,85 @@
+// Discover a SOAP service: typed catalog of operations and types from its WSDL, open questions, and proposed read/mutating classes; no LLM unless a judgment seat is set.
+//
+// The task text is the WSDL location, a path (relative to the launch
+// directory) or an http(s) URL:
+//
+//   llm4ts run soap-discover --repo ~/work/conti-api ./wsdl/DemoBank.wsdl
+//
+// Writes under <repo>/.llm4ts/soap/<service>/:
+//
+//   catalog.json    the typed catalog every later soap-* step reads
+//   catalog.md      a human summary: endpoints, operations, fields, open questions
+//   operations.md   proposed read/mutating classes; review, then set
+//                   `Status: confirmed`. An existing file is kept as is.
+//
+// The catalog is read by code (document/literal SOAP 1.1/1.2 bindings, WSDL
+// 1.1 and 2.0); anything it does not model is an open question, never a
+// guess. Classes are proposed by a name heuristic and, when
+// LLM4TS_JUDGMENT_PROVIDER names a judgment seat, by a typed judgment.
+// LLM4TS_SOAP_SERVICE overrides the service directory name. For a URL, the
+// fetch side of <repo>/.llm4ts/soap/<LLM4TS_SOAP_SERVICE>/auth.json (Basic,
+// Bearer, mTLS; references only) authenticates every document request.
+import { isAbsolute, resolve } from "node:path";
+import * as Effect from "effect/Effect";
+import { Info, makeNodeWorkspace, mock, resolveFlowInput, runFlowMain, runNode } from "@llm4ts/runner";
+import { judgmentConnectorFromEnvironment } from "@llm4ts/runner/Connectors";
+import { nodeSecretSource, resolveSide } from "./lib/soap/Auth.js";
+import { discoverService, loadAuthProfile } from "./lib/soap/Discover.js";
+import { makeNodeSoapTransport, makeTransportDocumentLoader } from "./lib/soap/Transport.js";
+import { DocumentLoader } from "./lib/soap/Wsdl.js";
+const isUrl = (location) => /^https?:\/\//i.test(location);
+const program = Effect.gen(function* () {
+    const input = yield* resolveFlowInput();
+    const raw = input.prompt.trim();
+    const location = isUrl(raw) || isAbsolute(raw) ? raw : resolve(input.workspace, raw);
+    const judgment = yield* judgmentConnectorFromEnvironment();
+    const service = process.env.LLM4TS_SOAP_SERVICE?.trim();
+    yield* runNode({
+        workDir: input.workDir,
+        workspace: input.workspace,
+        userPrompt: input.prompt,
+        // Discovery is deterministic; the mock seat only satisfies the context shape.
+        coder: mock,
+        ...(judgment === undefined ? {} : { judgment }),
+        environment: process.env
+    }, (context) => Effect.gen(function* () {
+        const say = (message) => context.events.publish(Info.make({ message }));
+        const workspace = yield* makeNodeWorkspace(input.workDir);
+        const profile = service === undefined || service === ""
+            ? undefined
+            : yield* loadAuthProfile(workspace, service);
+        if (isUrl(location) && profile === undefined) {
+            yield* say("fetching without credentials (set LLM4TS_SOAP_SERVICE and write its auth.json for an authenticated WSDL)");
+        }
+        const fetchSide = yield* resolveSide(nodeSecretSource(), profile?.fetch);
+        const loader = makeTransportDocumentLoader(makeNodeSoapTransport(), fetchSide);
+        const result = yield* discoverService({
+            workspace,
+            location,
+            ...(service === undefined || service === "" ? {} : { service }),
+            ...(judgment === undefined || context.judgment === undefined
+                ? {}
+                : { judgment: context.judgment })
+        }).pipe(Effect.provideService(DocumentLoader, loader));
+        const { catalog } = result;
+        yield* say(`${result.service}: ${catalog.operations.length} operations, ${catalog.endpoints.length} endpoints, ${catalog.documents.length} documents, ${catalog.openQuestions.length} open questions`);
+        for (const question of catalog.openQuestions) {
+            yield* say(`  open question [${question.code}] ${question.subject}: ${question.detail}`);
+        }
+        if (result.proposals !== undefined) {
+            const count = (kind) => result.proposals?.filter((proposal) => proposal.proposed === kind).length ?? 0;
+            yield* say(`proposed classes: ${count("read")} read, ${count("mutating")} mutating, ${count("unclassified")} unclassified — review ${result.paths.operations} and set Status: confirmed`);
+        }
+        else if (result.existing !== undefined) {
+            yield* say(`kept ${result.paths.operations} (${result.existing.confirmed ? "confirmed" : "still proposed"})`);
+            if (result.drift.missing.length > 0) {
+                yield* say(`  not classified there (treated as unclassified): ${result.drift.missing.join(", ")}`);
+            }
+            if (result.drift.unknown.length > 0) {
+                yield* say(`  no longer in the WSDL: ${result.drift.unknown.join(", ")}`);
+            }
+        }
+        yield* say(`wrote ${result.paths.catalog} and ${result.paths.summary}`);
+    }));
+});
+runFlowMain(program);