stageflow 0.13.0 → 0.15.0

package/dist/agent/piAdapter.js

@@ -390,10 +390,10 @@ function buildUserPrompt(input, emitToolName, emitHintOverride, artifactToolName
             if (successor.cloneInputSchema === undefined) {
                 return header;
             }
-            return `${header}\n  Assignment schema (clone_input_schema):\n${JSON.stringify(successor.cloneInputSchema, null, 2)}`;
+            return `${header}\n  Assignment schema (io.input.schema):\n${JSON.stringify(successor.cloneInputSchema, null, 2)}`;
         });
         emitHint += `\nClonable successors — emit clone_forks covering each of these ids exactly once:\n${successorLines.join("\n")}`;
-        emitHint += `\nEach once or fanout envelope is a full StageEnvelope — it requires status ("success" or "failure"), summary (non-empty string), and artifacts (array of strings). clone_input_schema fields belong in envelope.payload, not at the top level of the clone_forks item.`;
+        emitHint += `\nEach once or fanout envelope is a full StageEnvelope — it requires status ("success" or "failure"), summary (non-empty string), and artifacts (array of strings). io.input.schema fields belong in envelope.payload, not at the top level of the clone_forks item.`;
         emitHint += `\nAllowed clone actions: ${allowedActions.join(", ")}`;
     }
     if (input.feedbackLoopEmitContext !== undefined) {
@@ -431,6 +431,9 @@ function buildUserPrompt(input, emitToolName, emitHintOverride, artifactToolName
         `Goal: ${input.task.goal}`,
         input.task.context ? `Context: ${input.task.context}` : "",
         input.task.constraints ? `Constraints: ${input.task.constraints}` : "",
+        input.task.input !== undefined
+            ? `Input: ${JSON.stringify(input.task.input, null, 2)}`
+            : "",
         formatPriorEnvelope(input.priorEnvelope, input.priorEnvelopes, input.priorEnvelopesByStage),
         input.feedbackLoopContext !== undefined
             ? formatFeedbackLoopContext(input.feedbackLoopContext, input.sessionMode)

package/dist/agent/port.d.ts

@@ -1,7 +1,7 @@
 import type { StageEnvelope, TerminalEnvelope } from "../types/envelope.js";
 import type { CompletionContract } from "../types/completion.js";
 import type { CloneEmitContext, ForkEmitContext } from "../types/forkChoice.js";
-import type { StageConfig } from "../types/stage.js";
+import type { LoadedStageConfig } from "../types/stage.js";
 import type { FeedbackLoopConfig } from "../types/pipeline.js";
 import type { TaskFile } from "../types/task.js";
 import type { StageActivityEvent } from "./activity.js";
@@ -45,7 +45,7 @@ export type FeedbackLoopContext = {
 };
 export type StageRunInput = {
     roots: StageRoots;
-    stage: StageConfig;
+    stage: LoadedStageConfig;
     /** Runtime instance id (`work~2`). Defaults to `stage.id` when omitted. */
     stageId?: string;
     task: TaskFile;

package/dist/cli/initTemplates.d.ts

@@ -1,3 +1,3 @@
 export declare const STAGEFLOW_YAML = "version: 1\ncatalog:\n  pipelines:\n    - pipelines\n  tasks:\n    - tasks\n  patterns:\n    pipeline: \"*.pipeline.yaml\"\n    task: \"*.task.yaml\"\n";
-export declare const HELLO_PIPELINE_YAML = "id: hello\nstages:\n  - id: hello\n    system_prompt: Say hello and emit a success envelope.\n    model: anthropic/claude-sonnet-4-5\n";
+export declare const HELLO_PIPELINE_YAML = "id: hello\nmodel: anthropic/claude-sonnet-4-5\nstages:\n  - id: hello\n    system_prompt: Say hello and emit a success envelope.\n";
 export declare const HELLO_TASK_YAML = "id: hello\ngoal: Run the hello pipeline scaffold.\n";

package/dist/cli/initTemplates.js

@@ -9,10 +9,10 @@ catalog:
     task: "*.task.yaml"
 `;
 export const HELLO_PIPELINE_YAML = `id: hello
+model: anthropic/claude-sonnet-4-5
 stages:
   - id: hello
     system_prompt: Say hello and emit a success envelope.
-    model: anthropic/claude-sonnet-4-5
 `;
 export const HELLO_TASK_YAML = `id: hello
 goal: Run the hello pipeline scaffold.

package/dist/cli/migrateYamlCommand.d.ts

@@ -0,0 +1,18 @@
+export declare const MIGRATE_YAML_USAGE = "Usage:\n  sf migrate-yaml [path] [--root <path>] [--write] [--json] [--force]\n\n  Convert legacy catalog YAML to target YAML (io / verify / on_verify_fail).\n  Dry-run is the default. --write applies changes. Path may be a pipeline,\n  stage, task, or catalog root. Does not rewrite .stageflow snapshots.";
+export type MigrateYamlCommandIo = {
+    log: (line: string) => void;
+    error: (line: string) => void;
+};
+export type MigrateYamlJson = {
+    ok: boolean;
+    write: boolean;
+    planned: string[];
+    written: string[];
+    skipped: string[];
+    errors: string[];
+};
+export declare function runMigrateYamlCommand(args: string[], options?: {
+    cwd?: string;
+    projectRoot?: string;
+    io?: Partial<MigrateYamlCommandIo>;
+}): Promise<number>;

package/dist/cli/migrateYamlCommand.js

@@ -0,0 +1,180 @@
+import path from "node:path";
+import { applyMigrateYamlPlan, fileDirtyVsHead, planMigrateYaml, } from "../config/migrateYaml.js";
+export const MIGRATE_YAML_USAGE = `Usage:
+  sf migrate-yaml [path] [--root <path>] [--write] [--json] [--force]
+
+  Convert legacy catalog YAML to target YAML (io / verify / on_verify_fail).
+  Dry-run is the default. --write applies changes. Path may be a pipeline,
+  stage, task, or catalog root. Does not rewrite .stageflow snapshots.`;
+const defaultIo = {
+    log: (line) => console.log(line),
+    error: (line) => console.error(line),
+};
+function parseMigrateYamlArgs(args) {
+    if (args.length === 0) {
+        return { help: false, write: false, json: false, force: false };
+    }
+    if (args[0] === "--help" || args[0] === "-h") {
+        return { help: true, write: false, json: false, force: false };
+    }
+    let target;
+    let root;
+    let write = false;
+    let json = false;
+    let force = false;
+    let help = false;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--help" || arg === "-h") {
+            help = true;
+        }
+        else if (arg === "--write") {
+            write = true;
+        }
+        else if (arg === "--json") {
+            json = true;
+        }
+        else if (arg === "--force") {
+            force = true;
+        }
+        else if (arg === "--root") {
+            const value = args[++i];
+            if (value === undefined || value.length === 0) {
+                throw new Error("Missing value for --root");
+            }
+            root = value;
+        }
+        else if (arg.startsWith("-")) {
+            throw new Error(`Unknown flag: ${arg}`);
+        }
+        else if (target !== undefined) {
+            throw new Error(`Unexpected argument: ${arg}`);
+        }
+        else {
+            target = arg;
+        }
+    }
+    if (target !== undefined && root !== undefined) {
+        throw new Error("Use at most one of a positional path or --root");
+    }
+    return { help, target: target ?? root, write, json, force };
+}
+function planToJson(plan, options) {
+    return {
+        ok: options.ok,
+        write: options.write,
+        planned: plan.writes.map((item) => item.file),
+        written: options.written,
+        skipped: plan.skipped,
+        errors: [...plan.errors, ...(options.extraErrors ?? [])],
+    };
+}
+function formatHuman(plan, write, extraErrors) {
+    const lines = [];
+    const errors = [...plan.errors, ...extraErrors];
+    if (errors.length > 0) {
+        lines.push("Migration failed:");
+        for (const error of errors)
+            lines.push(`  ${error}`);
+        return lines.join("\n");
+    }
+    if (write) {
+        if (plan.writes.length === 0) {
+            lines.push("Nothing to write.");
+        }
+        else {
+            lines.push("Wrote:");
+            for (const item of plan.writes)
+                lines.push(`  ${item.file}`);
+        }
+    }
+    else if (plan.writes.length === 0) {
+        lines.push("Nothing to migrate.");
+    }
+    else {
+        lines.push("Would write:");
+        for (const item of plan.writes)
+            lines.push(`  ${item.file}`);
+        lines.push("");
+        lines.push("Dry-run; pass --write to apply.");
+    }
+    if (plan.skipped.length > 0) {
+        lines.push("");
+        lines.push("Skipped:");
+        for (const file of plan.skipped)
+            lines.push(`  ${file}`);
+    }
+    return lines.join("\n");
+}
+export async function runMigrateYamlCommand(args, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const projectRoot = options.projectRoot ?? cwd;
+    const out = { ...defaultIo, ...options.io };
+    try {
+        const parsed = parseMigrateYamlArgs(args);
+        if (parsed.help) {
+            out.error(MIGRATE_YAML_USAGE);
+            return 0;
+        }
+        const target = path.resolve(cwd, parsed.target ?? ".");
+        const plan = await planMigrateYaml(target, { cwd, projectRoot });
+        const extraErrors = [];
+        if (plan.errors.length > 0) {
+            if (parsed.json) {
+                out.log(JSON.stringify(planToJson(plan, { write: parsed.write, written: [], ok: false }), null, 2));
+            }
+            else {
+                out.error(formatHuman(plan, parsed.write, extraErrors));
+                out.error(MIGRATE_YAML_USAGE);
+            }
+            return 1;
+        }
+        if (parsed.write && !parsed.force) {
+            for (const item of plan.writes) {
+                if (fileDirtyVsHead(item.absPath)) {
+                    extraErrors.push(`Refusing to overwrite uncommitted changes in ${item.file} (pass --force)`);
+                }
+            }
+            if (extraErrors.length > 0) {
+                if (parsed.json) {
+                    out.log(JSON.stringify(planToJson(plan, {
+                        write: true,
+                        written: [],
+                        ok: false,
+                        extraErrors,
+                    }), null, 2));
+                }
+                else {
+                    out.error(formatHuman(plan, parsed.write, extraErrors));
+                }
+                return 1;
+            }
+        }
+        let written = [];
+        if (parsed.write) {
+            await applyMigrateYamlPlan(plan);
+            written = plan.writes.map((item) => item.file);
+        }
+        if (parsed.json) {
+            out.log(JSON.stringify(planToJson(plan, {
+                write: parsed.write,
+                written,
+                ok: true,
+            }), null, 2));
+        }
+        else {
+            out.log(formatHuman(plan, parsed.write, extraErrors));
+        }
+        return 0;
+    }
+    catch (err) {
+        const message = err instanceof Error
+            ? err.message
+            : typeof err === "string"
+                ? err
+                : "Migrate-yaml command failed";
+        out.error(message);
+        out.error(MIGRATE_YAML_USAGE);
+        return 1;
+    }
+}

package/dist/cli/runOutput.js

@@ -46,30 +46,38 @@ function formatStartFailureJson(started) {
     return formatRunStartFailedJson(started);
 }
 function baseRunCompletionPayload(result) {
-    if (result.outcome === "succeeded") {
-        return {
+    const payload = result.outcome === "succeeded"
+        ? {
             ok: true,
             outcome: "succeeded",
             runId: result.runId,
             runDir: result.runDir,
-        };
+        }
+        : result.outcome === "waiting"
+            ? {
+                ok: false,
+                outcome: "waiting",
+                runId: result.runId,
+                runDir: result.runDir,
+            }
+            : {
+                ok: false,
+                outcome: "failed",
+                runId: result.runId,
+                runDir: result.runDir,
+            };
+    if (result.outcome === "failed" && result.reason !== undefined) {
+        payload.reason = result.reason;
     }
-    if (result.outcome === "waiting") {
-        return {
-            ok: false,
-            outcome: "waiting",
-            runId: result.runId,
-            runDir: result.runDir,
-        };
+    if (Array.isArray(result.findings) && result.findings.length > 0) {
+        payload.findings = result.findings.map((finding) => ({
+            severity: finding.severity,
+            code: finding.code,
+            file: finding.path,
+            message: finding.message,
+            category: finding.category,
+        }));
     }
-    const payload = {
-        ok: false,
-        outcome: "failed",
-        runId: result.runId,
-        runDir: result.runDir,
-    };
-    if (result.reason !== undefined)
-        payload.reason = result.reason;
     return payload;
 }
 function formatRunCompletionJson(result) {

package/dist/cli/validateCommand.d.ts

@@ -6,6 +6,7 @@ export type ValidateCommandIo = {
 };
 export declare function runValidateCommand(args: string[], options?: {
     cwd?: string;
+    projectRoot?: string;
     io?: Partial<ValidateCommandIo>;
     validateCatalog?: (options: Parameters<typeof defaultValidateCatalog>[0]) => Promise<ValidationResult>;
 }): Promise<number>;

package/dist/cli/validateCommand.js

@@ -61,6 +61,7 @@ function parseValidateArgs(args) {
 }
 export async function runValidateCommand(args, options = {}) {
     const cwd = options.cwd ?? process.cwd();
+    const projectRoot = options.projectRoot ?? cwd;
     const out = { ...defaultIo, ...options.io };
     const validateCatalogFn = options.validateCatalog ?? defaultValidateCatalog;
     try {
@@ -73,6 +74,7 @@ export async function runValidateCommand(args, options = {}) {
         const result = await validateCatalogFn({
             scope,
             cwd,
+            projectRoot,
             pipeline: parsed.pipeline,
             task: parsed.task,
             strict: parsed.strict,

package/dist/cli.js

@@ -14,6 +14,7 @@ import { RUNS_USAGE, runRunsCommand } from "./cli/runsCommand.js";
 import { resolveOperatorCatalog } from "./cli/operatorCatalog.js";
 import { SKILLS_USAGE, runSkillsCommand } from "./cli/skillsCommand.js";
 import { VALIDATE_USAGE, runValidateCommand } from "./cli/validateCommand.js";
+import { MIGRATE_YAML_USAGE, runMigrateYamlCommand } from "./cli/migrateYamlCommand.js";
 import { createRunStore } from "./runstore/createStore.js";
 import { resolveStageflowContext } from "./project/resolveStageflowContext.js";
 import { exitForOutcome, runStageWorker } from "./runtime/stageWorker.js";
@@ -26,6 +27,7 @@ const USAGE = `Usage:
   sf init
   sf run --task <path> --pipeline <path> [--checkout <path>] [--json] [--include stages] [--skip-gates] [--git-sha <sha>] [--ci-pr-url <url>] [--ci-job-url <url>] [--operator-cwd <path>] [--operator-agent-dir <path>]
   sf validate [--pipeline <path>] [--task <path>] [--strict] [--json]
+  sf migrate-yaml [path] [--root <path>] [--write] [--json] [--force]
   sf artifact read --run <runId> --path <relPath> [--out <file>]
   sf envelope get --run <runId> --stage <stageId> [--json] [--from <sf-run.json>] [--detect-stage <id>] [--format envelope|handoff]
   sf export-run --run <runId> [--from <sf-run.json>] [--out <file>]
@@ -64,6 +66,8 @@ ${RUN_USAGE}
 
 ${VALIDATE_USAGE}
 
+${MIGRATE_YAML_USAGE}
+
 ${ARTIFACT_USAGE}
 
 ${ENVELOPE_USAGE}
@@ -93,6 +97,7 @@ function parseArgs(argv) {
     const command = args[0];
     if (command === "providers" ||
         command === "validate" ||
+        command === "migrate-yaml" ||
         command === "run" ||
         command === "init" ||
         command === "artifact" ||
@@ -275,7 +280,16 @@ async function main(argv) {
             return runInitCommand(argv.slice(3), { cwd: ctx.invocationCwd });
         }
         if (parsed.command === "validate") {
-            return runValidateCommand(argv.slice(3), { cwd: ctx.invocationCwd });
+            return runValidateCommand(argv.slice(3), {
+                cwd: ctx.invocationCwd,
+                projectRoot: ctx.projectRoot,
+            });
+        }
+        if (parsed.command === "migrate-yaml") {
+            return runMigrateYamlCommand(argv.slice(3), {
+                cwd: ctx.invocationCwd,
+                projectRoot: ctx.projectRoot,
+            });
         }
         if (parsed.command === "run") {
             return runRunCommand(argv.slice(3), {

package/dist/config/browseCatalog.js

@@ -106,7 +106,7 @@ async function listModelsFromManifest(projectRoot, manifest) {
         try {
             const loaded = await loadPipeline(filePath, { cwd: projectRoot });
             for (const stage of loaded.stages) {
-                if (stage.model.trim()) {
+                if (stage.model?.trim()) {
                     models.add(stage.model);
                 }
             }

package/dist/config/createPipeline.d.ts

@@ -3,7 +3,7 @@ import type { StageGateKind } from "../types/stage.js";
 import type { PipelineListing } from "./listConfig.js";
 export type CreatePipelineStageInline = {
     system_prompt: string;
-    model: string;
+    model?: string;
     gate_kinds?: StageGateKind[];
 };
 export type CreatePipelineStageRef = {

package/dist/config/createPipeline.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { parsePipelineNeeds } from "./pipelineNeeds.js";
 import { STAGE_ID_PATTERN } from "./createStage.js";
 import { inferIdFromUsesPath, normalizePipelineStageEntries, toWiringRefs, } from "./normalizePipelineStageEntry.js";
+import { parseModelField } from "./modelField.js";
 import { readYamlObject } from "./readYamlObject.js";
 import { resolvePipelineDagFromRefs } from "./resolvePipelineDag.js";
 import { validatePipeline } from "./validateCatalog.js";
@@ -36,7 +37,9 @@ function stageRefToRaw(ref) {
         raw.uses = ref.uses;
     if (ref.inline) {
         raw.system_prompt = ref.inline.system_prompt;
-        raw.model = ref.inline.model;
+        if (ref.inline.model !== undefined && ref.inline.model.length > 0) {
+            raw.model = ref.inline.model;
+        }
         if (ref.inline.gate_kinds !== undefined) {
             raw.gate_kinds = ref.inline.gate_kinds;
         }
@@ -61,7 +64,9 @@ function normalizedToCreateRefs(entries) {
             const raw = entry.body.raw;
             ref.inline = {
                 system_prompt: String(raw.system_prompt ?? ""),
-                model: String(raw.model ?? ""),
+                ...(typeof raw.model === "string" && raw.model.length > 0
+                    ? { model: raw.model }
+                    : {}),
                 ...(Array.isArray(raw.gate_kinds)
                     ? { gate_kinds: raw.gate_kinds }
                     : {}),
@@ -97,17 +102,22 @@ function parseInlineBody(entry, index) {
             error: `stages[${index}].system_prompt is required for inline stage`,
         };
     }
-    if (typeof entry.model !== "string" || entry.model.length === 0) {
-        return {
-            ok: false,
-            status: 400,
-            error: `stages[${index}].model is required for inline stage`,
-        };
-    }
     const inline = {
         system_prompt: entry.system_prompt,
-        model: entry.model,
     };
+    if (entry.model !== undefined) {
+        const modelField = parseModelField(entry.model);
+        if (!modelField.ok) {
+            return {
+                ok: false,
+                status: 400,
+                error: `stages[${index}].${modelField.message}`,
+            };
+        }
+        if (modelField.value !== undefined) {
+            inline.model = modelField.value;
+        }
+    }
     if (entry.gate_kinds !== undefined) {
         if (!Array.isArray(entry.gate_kinds)) {
             return {
@@ -288,7 +298,9 @@ export function pipelineConfigToYaml(pipeline, options) {
             else {
                 lines.push(`    system_prompt: ${formatInlineYamlScalar(stage.inline.system_prompt)}`);
             }
-            lines.push(`    model: ${formatInlineYamlScalar(stage.inline.model)}`);
+            if (stage.inline.model !== undefined && stage.inline.model.length > 0) {
+                lines.push(`    model: ${formatInlineYamlScalar(stage.inline.model)}`);
+            }
         }
         else if (stage.uses) {
             lines.push(`    uses: ${stage.uses}`);

package/dist/config/createStage.d.ts

@@ -5,7 +5,7 @@ export type CreateStageInput = {
     filename: string;
     id: string;
     system_prompt: string;
-    model: string;
+    model?: string;
     gate_kinds?: StageGateKind[];
 };
 export type CreatedStageListing = {

package/dist/config/createStage.js

@@ -2,6 +2,7 @@ import { access, mkdir, readdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { STAGE_GATE_KINDS, } from "../types/stage.js";
 import { loadStage } from "./loadStage.js";
+import { parseModelField } from "./modelField.js";
 import { readYamlObject } from "./readYamlObject.js";
 export const STAGE_ID_PATTERN = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 function isGateKind(value) {
@@ -63,9 +64,11 @@ export function parseCreateStageBody(body) {
     if (typeof body.system_prompt !== "string" || body.system_prompt.length === 0) {
         return { ok: false, status: 400, error: "system_prompt is required" };
     }
-    if (typeof body.model !== "string" || body.model.length === 0) {
-        return { ok: false, status: 400, error: "model is required" };
+    const modelField = parseModelField(body.model);
+    if (!modelField.ok) {
+        return { ok: false, status: 400, error: modelField.message };
     }
+    const model = modelField.value;
     const gateKinds = parseGateKinds(body.gate_kinds);
     if (gateKinds === "invalid") {
         return {
@@ -79,7 +82,7 @@ export function parseCreateStageBody(body) {
         filename,
         id: body.id,
         system_prompt: body.system_prompt,
-        model: body.model,
+        ...(model !== undefined ? { model } : {}),
         ...(gateKinds !== undefined ? { gate_kinds: gateKinds } : {}),
     };
 }
@@ -116,7 +119,9 @@ export function stageConfigToYaml(stage) {
     else {
         lines.push(`system_prompt: ${formatInlineYamlScalar(stage.system_prompt)}`);
     }
-    lines.push(`model: ${formatInlineYamlScalar(stage.model)}`);
+    if (stage.model !== undefined && stage.model.length > 0) {
+        lines.push(`model: ${formatInlineYamlScalar(stage.model)}`);
+    }
     lines.push("");
     return lines.join("\n");
 }
@@ -190,7 +195,7 @@ export async function createStage(projectRoot, input) {
         await writeFile(filePath, stageConfigToYaml({
             id: input.id,
             system_prompt: input.system_prompt,
-            model: input.model,
+            ...(input.model !== undefined && input.model.length > 0 ? { model: input.model } : {}),
             ...(input.gate_kinds !== undefined ? { gate_kinds: input.gate_kinds } : {}),
         }), "utf8");
     }

package/dist/config/legacyYaml.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Dual-read adapter: accept old YAML authoring keys and warn (`catalog.legacy_yaml`).
+ *
+ * This is not the runtime IR. Stage workers, snapshots, emit, and VSE already
+ * use those same strings as TypeScript fields (`StageConfig.payload_schema`,
+ * DAG `completion` / `recovery`). Target YAML compiles onto that IR in
+ * `yamlDialect.ts`. New catalog fields go on `io` / `verify` / `on_verify_fail`,
+ * not here.
+ *
+ * Off: STAGEFLOW_LEGACY_YAML=0. migrate-yaml still reads legacy via
+ * withLegacyYamlAllowedAsync.
+ *
+ * Delete this file plus migrateYaml.ts, printTargetYaml.ts,
+ * migrateYamlCommand.ts, and tests/fixtures/dual-read to stop accepting
+ * payload_schema / pre_emit_checks / completion / recovery as authoring keys.
+ */
+import type { LoadIssue } from "./loadOutcome.js";
+import type { YamlDialect } from "./yamlDialect.js";
+export declare const LEGACY_CONTRACT_KEYS: Set<string>;
+export declare const LEGACY_KEY_REPLACEMENTS: Record<string, string>;
+export declare function formatLegacyReplacements(keys: string[]): string;
+export declare function presentLegacyKeys(keys: Iterable<string>): string[];
+export declare function legacyYamlIssue(fileLabel: string, keys: string[]): LoadIssue;
+export declare function dialectWarningForDocument(raw: Record<string, unknown>, fileLabel: string): LoadIssue | undefined;
+export declare function allowLegacyYamlAuthoring(): boolean;
+export declare function withLegacyYamlAllowed<T>(fn: () => T): T;
+export declare function withLegacyYamlAllowedAsync<T>(fn: () => Promise<T>): Promise<T>;
+export declare function legacyAuthoringRejected(dialect: YamlDialect, fileLabel: string, keys: string[]): LoadIssue | undefined;