stageflow 0.23.0 → 0.27.0

package/dist/config/listSkills.js

@@ -1,6 +1,7 @@
-import { access } from "node:fs/promises";
+import { access, readFile, readdir } from "node:fs/promises";
+import path from "node:path";
 import { DefaultResourceLoader, SettingsManager, } from "@earendil-works/pi-coding-agent";
-function toListing(skill) {
+function toListing(skill, origin) {
     return {
         name: skill.name,
         description: skill.description,
@@ -9,8 +10,39 @@ function toListing(skill) {
         scope: skill.sourceInfo.scope,
         source: skill.sourceInfo.source,
         disableModelInvocation: skill.disableModelInvocation,
+        ...(origin !== undefined ? { origin } : {}),
     };
 }
+function isUnderRoot(candidate, root) {
+    const resolvedRoot = path.resolve(root);
+    const resolved = path.resolve(candidate);
+    const rel = path.relative(resolvedRoot, resolved);
+    return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+}
+async function pathExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function descriptionFromSkillMd(content) {
+    const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
+    if (!match)
+        return undefined;
+    const block = match[1];
+    const descLine = /^description:\s*(.*)$/m.exec(block);
+    if (!descLine)
+        return undefined;
+    let value = descLine[1].trim();
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        value = value.slice(1, -1);
+    }
+    return value.length > 0 ? value : undefined;
+}
 async function openSkillCatalogLoader(options) {
     const settingsManager = SettingsManager.create(options.cwd, options.agentDir, {
         projectTrusted: true,
@@ -23,7 +55,67 @@ async function openSkillCatalogLoader(options) {
     await loader.reload();
     return loader;
 }
+async function resolveRunSkill(name, runSkillsDir) {
+    if (name.includes("/") || name.includes("\\") || name.includes("\0")) {
+        return undefined;
+    }
+    const baseDir = path.join(runSkillsDir, name);
+    const filePath = path.join(baseDir, "SKILL.md");
+    if (!(await pathExists(filePath)))
+        return undefined;
+    return {
+        name,
+        filePath,
+        baseDir,
+        scope: "temporary",
+        source: "run",
+        origin: "run",
+    };
+}
+async function resolveCheckoutSkill(name, checkoutRoot) {
+    if (name.includes("/") || name.includes("\\") || name.includes("\0")) {
+        return undefined;
+    }
+    const baseDir = path.join(checkoutRoot, ".pi", "skills", name);
+    const filePath = path.join(baseDir, "SKILL.md");
+    if (!(await pathExists(filePath)))
+        return undefined;
+    return {
+        name,
+        filePath,
+        baseDir,
+        scope: "project",
+        source: "checkout",
+        origin: "checkout",
+    };
+}
+function originForLoaderSkill(skill, options) {
+    if (options.checkoutRoot !== undefined &&
+        isUnderRoot(skill.filePath, path.join(options.checkoutRoot, ".pi", "skills"))) {
+        return "checkout";
+    }
+    if (isUnderRoot(skill.filePath, path.join(options.agentDir, "skills"))) {
+        return "host";
+    }
+    if (skill.sourceInfo.scope === "project") {
+        return "checkout";
+    }
+    return "host";
+}
+/**
+ * Resolve a skill by name. Search order: run skills → checkout `.pi/skills` → host agentDir.
+ */
 export async function resolveSkillByName(name, options) {
+    if (options.runSkillsDir !== undefined) {
+        const run = await resolveRunSkill(name, options.runSkillsDir);
+        if (run)
+            return run;
+    }
+    if (options.checkoutRoot !== undefined) {
+        const checkout = await resolveCheckoutSkill(name, options.checkoutRoot);
+        if (checkout)
+            return checkout;
+    }
     const loader = await openSkillCatalogLoader(options);
     const match = loader.getSkills().skills.find((skill) => skill.name === name);
     if (!match)
@@ -34,10 +126,24 @@ export async function resolveSkillByName(name, options) {
     catch {
         return undefined;
     }
+    if (options.checkoutRoot !== undefined &&
+        isUnderRoot(match.filePath, path.join(options.checkoutRoot, ".pi", "skills"))) {
+        return {
+            name: match.name,
+            filePath: match.filePath,
+            baseDir: match.baseDir,
+            scope: match.sourceInfo.scope,
+            source: match.sourceInfo.source,
+            origin: "checkout",
+        };
+    }
     return {
         name: match.name,
         filePath: match.filePath,
         baseDir: match.baseDir,
+        scope: match.sourceInfo.scope,
+        source: match.sourceInfo.source,
+        origin: originForLoaderSkill(match, options),
     };
 }
 export async function listSkills(options) {
@@ -45,7 +151,7 @@ export async function listSkills(options) {
     const { skills, diagnostics } = loader.getSkills();
     return {
         skills: skills
-            .map(toListing)
+            .map((skill) => toListing(skill, originForLoaderSkill(skill, options)))
             .sort((a, b) => a.name.localeCompare(b.name)),
         diagnostics: diagnostics.map((d) => ({
             message: d.message,
@@ -53,3 +159,84 @@ export async function listSkills(options) {
         })),
     };
 }
+async function listRunSkillOrigins(runSkillsDir) {
+    let names;
+    try {
+        names = await readdir(runSkillsDir);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const name of names) {
+        if (name.includes("/") || name.includes("\\") || name.includes("\0")) {
+            continue;
+        }
+        const filePath = path.join(runSkillsDir, name, "SKILL.md");
+        try {
+            const content = await readFile(filePath, "utf8");
+            const description = descriptionFromSkillMd(content);
+            if (description === undefined)
+                continue;
+            out.push({ name, description, origin: "run" });
+        }
+        catch {
+            // skip unreadable / incomplete packs
+        }
+    }
+    return out;
+}
+/**
+ * List skills with SkillOrigin. When runSkillsDir is set, run-tier skills win on name.
+ * Precedence for the merged view: run → checkout → host.
+ */
+export async function listSkillsWithOrigin(options) {
+    const byName = new Map();
+    const hostCatalog = await listSkills({
+        cwd: options.cwd,
+        agentDir: options.agentDir,
+        ...(options.checkoutRoot !== undefined
+            ? { checkoutRoot: options.checkoutRoot }
+            : {}),
+    });
+    for (const skill of hostCatalog.skills) {
+        const origin = skill.origin ??
+            (skill.scope === "project" ? "checkout" : "host");
+        byName.set(skill.name, {
+            name: skill.name,
+            description: skill.description,
+            origin,
+        });
+    }
+    if (options.checkoutRoot !== undefined) {
+        let checkoutNames = [];
+        try {
+            checkoutNames = await readdir(path.join(options.checkoutRoot, ".pi", "skills"));
+        }
+        catch {
+            checkoutNames = [];
+        }
+        for (const name of checkoutNames) {
+            const filePath = path.join(options.checkoutRoot, ".pi", "skills", name, "SKILL.md");
+            try {
+                const content = await readFile(filePath, "utf8");
+                const description = descriptionFromSkillMd(content);
+                if (description === undefined)
+                    continue;
+                byName.set(name, { name, description, origin: "checkout" });
+            }
+            catch {
+                // skip
+            }
+        }
+    }
+    if (options.runSkillsDir !== undefined) {
+        for (const skill of await listRunSkillOrigins(options.runSkillsDir)) {
+            byName.set(skill.name, skill);
+        }
+    }
+    return {
+        skills: [...byName.values()].sort((a, b) => a.name.localeCompare(b.name)),
+        diagnostics: hostCatalog.diagnostics,
+    };
+}

package/dist/config/loadOutcome.d.ts

@@ -1,5 +1,5 @@
 import type { ValidationFindingCode } from "./validateCatalog.js";
-export type TaskLoadCode = "task.invalid_shape" | "task.load_error";
+export type TaskLoadCode = "task.invalid_shape" | "task.load_error" | "task.binding_conflict" | "task.repository_ref_required" | "task.ref_without_repository" | "task.repository_invalid";
 export type LoadIssue = {
     code: ValidationFindingCode;
     message: string;

package/dist/config/loadPipeline.js

@@ -12,6 +12,7 @@ import { recoveryRequiresCompletionIssue } from "./parseCompletionContract.js";
 import { validateCompletionContractForStage } from "./validateCompletionContract.js";
 import { applyCloneChains } from "./cloneChain.js";
 import { collectRouteIfSchemaIssues, collectRouteIfIllegalCombos, collectRouteAllGatedWarnings, } from "./routeIf.js";
+import { mergeToolRequires } from "./toolRequires.js";
 function schemaCompileIssue(stageId, field, err, pipelineId) {
     const message = err instanceof Error ? err.message : String(err);
     if (err instanceof UnresolvedSchemaRefError) {
@@ -128,7 +129,7 @@ export async function loadPipelineFromObject(raw, options = {}) {
 }
 async function buildLoadedPipelineFromMerge(merge, options) {
     const { projectRoot, requireIo, pipelinePath } = options;
-    const { entries: rawEntries, pipelineId, agent: pipelineAgent, model: pipelineModel, schemas: pipelineSchemas, warnings: mergeWarnings, } = merge;
+    const { entries: rawEntries, pipelineId, agent: pipelineAgent, model: pipelineModel, schemas: pipelineSchemas, requires: pipelineRequires, warnings: mergeWarnings, } = merge;
     const ctx = { pipelineId, path: pipelinePath };
     const warnings = [...mergeWarnings];
     const normalizeOutcome = normalizePipelineStageEntries(rawEntries, ctx);
@@ -181,7 +182,14 @@ async function buildLoadedPipelineFromMerge(merge, options) {
             if (!inlineOutcome.ok) {
                 return loadFailure(inlineOutcome.issues);
             }
-            stages.push(inlineOutcome.value);
+            let stage = inlineOutcome.value;
+            if (entry.requires !== undefined) {
+                const merged = mergeToolRequires([stage.requires, entry.requires], { pipelineId, label: `stage "${entry.id}"` });
+                if (!merged.ok)
+                    return loadFailure(merged.issues);
+                stage = { ...stage, requires: merged.value };
+            }
+            stages.push(stage);
             stageSources[stageId] = { kind: "inline" };
             continue;
         }
@@ -229,10 +237,19 @@ async function buildLoadedPipelineFromMerge(merge, options) {
                 },
             ]);
         }
+        let stageRequires = stageOutcome.value.requires;
+        if (entry.requires !== undefined) {
+            const merged = mergeToolRequires([stageRequires, entry.requires], { pipelineId, label: `stage "${entry.id}"` });
+            if (!merged.ok)
+                return loadFailure(merged.issues);
+            stageRequires = merged.value;
+        }
         const stage = {
             ...stageOutcome.value,
             ...(entry.skill !== undefined ? { skill: entry.skill } : {}),
             ...(entry.mcp !== undefined ? { mcp: entry.mcp } : {}),
+            ...(entry.secrets !== undefined ? { secrets: entry.secrets } : {}),
+            ...(stageRequires !== undefined ? { requires: stageRequires } : {}),
         };
         stages.push(stage);
         stageSources[stageId] = { kind: "file", path: entry.body.absolutePath };
@@ -282,7 +299,11 @@ async function buildLoadedPipelineFromMerge(merge, options) {
         ...(pipelineAgent !== undefined ? { agent: pipelineAgent } : {}),
         ...(pipelineModel !== undefined ? { model: pipelineModel } : {}),
         ...(pipelineSchemas !== undefined ? { schemas: pipelineSchemas } : {}),
+        ...(pipelineRequires !== undefined ? { requires: pipelineRequires } : {}),
     };
+    const effectiveRequires = mergeToolRequires([pipelineRequires, ...loadedStages.map((s) => s.requires)], { pipelineId });
+    if (!effectiveRequires.ok)
+        return loadFailure(effectiveRequires.issues);
     const nodeById = new Map(dag.nodes.map((node) => [node.id, node]));
     for (const [stageId, after] of fileAfterById) {
         const node = nodeById.get(stageId);

package/dist/config/loadStage.js

@@ -7,6 +7,8 @@ import { parseModelField } from "./modelField.js";
 import { allowLegacyYamlAuthoring, dialectWarningForDocument, legacyAuthoringRejected, presentLegacyKeys, } from "./legacyYaml.js";
 import { parsePreEmitChecks } from "./parsePreEmitChecks.js";
 import { readYamlObject } from "./readYamlObject.js";
+import { parseStageSecrets } from "../runtime/stageSecretDecl.js";
+import { parseToolRequires } from "./toolRequires.js";
 import { classifyYamlDocument, compileTargetContract, dialectFromKeys, mixedDialectIssue, STAGE_FILE_WIRING_KEYS, } from "./yamlDialect.js";
 const afterCompletionByStage = new WeakMap();
 /** After-phase IR from target `verify` (`when` includes after). Stamped onto DAG `completion`. */
@@ -348,6 +350,22 @@ function parseStageFields(raw, label, entryId, deferSchemaRefs, requireIo, compi
     if (mcpOutcome.value !== undefined) {
         stage.mcp = mcpOutcome.value;
     }
+    const secretsOutcome = parseStageSecrets(raw.secrets, label, entryId);
+    if (!secretsOutcome.ok)
+        return secretsOutcome;
+    if (secretsOutcome.value !== undefined) {
+        stage.secrets = secretsOutcome.value;
+    }
+    const requiresOutcome = parseToolRequires(raw.requires, `stage ${label}`, {
+        code: "stage.invalid_requires",
+        category: "stage",
+        stageId: entryId,
+    });
+    if (!requiresOutcome.ok)
+        return requiresOutcome;
+    if (requiresOutcome.value !== undefined) {
+        stage.requires = requiresOutcome.value;
+    }
     const agentField = parseAgentField(raw.agent);
     if (!agentField.ok) {
         return loadFailure([

package/dist/config/loadTask.d.ts

@@ -1,5 +1,7 @@
 import type { TaskFile } from "../types/task.js";
 import { type LoadOutcome } from "./loadOutcome.js";
+/** Structural TaskFile shape only — does not enforce workspace binding XOR. */
+export declare function coerceTaskFile(raw: unknown): TaskFile | undefined;
 export declare function parseTaskFile(raw: unknown, source?: string): LoadOutcome<TaskFile>;
 export declare function loadTaskFromYamlOutcome(yamlText: string, source?: string): LoadOutcome<TaskFile>;
 export declare function loadTaskOutcome(filePath: string): Promise<LoadOutcome<TaskFile>>;

package/dist/config/loadTask.js

@@ -1,12 +1,60 @@
 import { readFile } from "node:fs/promises";
 import { parse as parseYaml } from "yaml";
+import { resolveWorkspaceBinding } from "../runtime/workspaceBinding.js";
 import { loadFailure, loadSuccess } from "./loadOutcome.js";
 function isPlainObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-export function parseTaskFile(raw, source = "task") {
+function parseGitIdentity(raw) {
+    if (!isPlainObject(raw))
+        return undefined;
+    const identity = {};
+    if (typeof raw.name === "string")
+        identity.name = raw.name;
+    if (typeof raw.email === "string")
+        identity.email = raw.email;
+    return identity;
+}
+/** Structural TaskFile shape only — does not enforce workspace binding XOR. */
+export function coerceTaskFile(raw) {
     const record = raw;
     if (typeof record?.id !== "string" || typeof record?.goal !== "string") {
+        return undefined;
+    }
+    if (record.input !== undefined && !isPlainObject(record.input)) {
+        return undefined;
+    }
+    return {
+        id: record.id,
+        goal: record.goal,
+        context: typeof record.context === "string" ? record.context : undefined,
+        constraints: typeof record.constraints === "string" ? record.constraints : undefined,
+        checkout: typeof record.checkout === "string" ? record.checkout : undefined,
+        ...(typeof record.repository === "string" ? { repository: record.repository } : {}),
+        ...(typeof record.ref === "string" ? { ref: record.ref } : {}),
+        ...(typeof record.run_branch_template === "string"
+            ? { run_branch_template: record.run_branch_template }
+            : {}),
+        ...(isPlainObject(record.git_identity)
+            ? { git_identity: parseGitIdentity(record.git_identity) }
+            : {}),
+        ...(record.input !== undefined ? { input: record.input } : {}),
+    };
+}
+export function parseTaskFile(raw, source = "task") {
+    const record = raw;
+    const task = coerceTaskFile(raw);
+    if (task === undefined) {
+        if (typeof record?.id === "string" && typeof record?.goal === "string") {
+            return loadFailure([
+                {
+                    code: "task.invalid_shape",
+                    message: `Invalid ${source}: input must be an object`,
+                    category: "task",
+                    taskId: record.id,
+                },
+            ]);
+        }
         return loadFailure([
             {
                 code: "task.invalid_shape",
@@ -16,24 +64,15 @@ export function parseTaskFile(raw, source = "task") {
             },
         ]);
     }
-    if (record.input !== undefined && !isPlainObject(record.input)) {
-        return loadFailure([
-            {
-                code: "task.invalid_shape",
-                message: `Invalid ${source}: input must be an object`,
-                category: "task",
-                taskId: record.id,
-            },
-        ]);
+    const binding = resolveWorkspaceBinding(task);
+    if (!binding.ok) {
+        return loadFailure(binding.issues.map((issue) => {
+            if (issue.category !== "task")
+                return issue;
+            return { ...issue, taskId: task.id };
+        }));
     }
-    return loadSuccess({
-        id: record.id,
-        goal: record.goal,
-        context: typeof record.context === "string" ? record.context : undefined,
-        constraints: typeof record.constraints === "string" ? record.constraints : undefined,
-        checkout: typeof record.checkout === "string" ? record.checkout : undefined,
-        ...(record.input !== undefined ? { input: record.input } : {}),
-    });
+    return loadSuccess(task);
 }
 export function loadTaskFromYamlOutcome(yamlText, source = "task yaml") {
     let raw;

package/dist/config/materializeStageModels.js

@@ -29,7 +29,11 @@ export async function materializeStageModels(stages, options) {
         if (!modelOutcome.ok) {
             return loadFailure(modelOutcome.issues);
         }
-        materialized.push({ ...stage, model: modelOutcome.value });
+        materialized.push({
+            ...stage,
+            model: modelOutcome.value.model,
+            model_tier: modelOutcome.value.tier,
+        });
     }
     return loadSuccess(materialized);
 }

package/dist/config/mergePipelineIncludes.d.ts

@@ -1,6 +1,7 @@
 import type { PayloadSchemaMap } from "../envelope/payloadSchema.js";
 import type { InlinePipelineDefinition } from "../types/pipeline.js";
 import { type LoadIssue, type LoadOutcome } from "./loadOutcome.js";
+import { type ToolRequirement } from "./toolRequires.js";
 export type RawMergedEntry = {
     raw: unknown;
     declaringPath: string;
@@ -11,6 +12,7 @@ export declare function mergePipelineStages(rootPath: string): Promise<LoadOutco
     agent?: string;
     model?: string;
     schemas?: PayloadSchemaMap;
+    requires?: ToolRequirement[];
     warnings: LoadIssue[];
 }>>;
 /** Synthetic `declaringPath` for stage entries with no backing file. */
@@ -21,5 +23,6 @@ export declare function mergeInlinePipelineStages(raw: InlinePipelineDefinition)
     agent?: string;
     model?: string;
     schemas?: PayloadSchemaMap;
+    requires?: ToolRequirement[];
     warnings: LoadIssue[];
 }>>;

package/dist/config/mergePipelineIncludes.js

@@ -4,6 +4,7 @@ import { loadFailure, loadSuccess } from "./loadOutcome.js";
 import { allowLegacyYamlAuthoring, dialectWarningForDocument, legacyAuthoringRejected, presentLegacyKeys, } from "./legacyYaml.js";
 import { parseModelField } from "./modelField.js";
 import { readYamlObject } from "./readYamlObject.js";
+import { parseToolRequires } from "./toolRequires.js";
 import { classifyYamlDocument, collectDocumentKeys, mixedDialectIssue, } from "./yamlDialect.js";
 function isPlainObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -177,6 +178,14 @@ export async function mergePipelineStages(rootPath) {
     if (!schemasOutcome.ok)
         return schemasOutcome;
     const schemas = schemasOutcome.value;
+    const requiresOutcome = parseToolRequires(raw.requires, `pipeline ${absRoot}`, {
+        code: "pipeline.invalid_requires",
+        category: "pipeline",
+        pipelineId,
+    });
+    if (!requiresOutcome.ok)
+        return requiresOutcome;
+    const requires = requiresOutcome.value;
     const idLocations = new Map();
     const entries = [];
     const warnings = [];
@@ -198,6 +207,7 @@ export async function mergePipelineStages(rootPath) {
         ...(agent !== undefined ? { agent } : {}),
         ...(model !== undefined ? { model } : {}),
         ...(schemas !== undefined ? { schemas } : {}),
+        ...(requires !== undefined ? { requires } : {}),
         warnings,
     });
 }
@@ -252,6 +262,14 @@ export async function mergeInlinePipelineStages(raw) {
     if (!schemasOutcome.ok)
         return schemasOutcome;
     const schemas = schemasOutcome.value;
+    const requiresOutcome = parseToolRequires(raw.requires, `inline pipeline ${pipelineId}`, {
+        code: "pipeline.invalid_requires",
+        category: "pipeline",
+        pipelineId,
+    });
+    if (!requiresOutcome.ok)
+        return requiresOutcome;
+    const requires = requiresOutcome.value;
     const entries = [];
     for (let index = 0; index < raw.stages.length; index++) {
         const entry = raw.stages[index];
@@ -273,6 +291,7 @@ export async function mergeInlinePipelineStages(raw) {
         ...(agent !== undefined ? { agent } : {}),
         ...(model !== undefined ? { model } : {}),
         ...(schemas !== undefined ? { schemas } : {}),
+        ...(requires !== undefined ? { requires } : {}),
         warnings: [],
     });
 }

package/dist/config/migrateYaml.js

@@ -1,7 +1,8 @@
-import { execFileSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { readdir, readFile, rename, stat, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { runGitSync } from "../git/exec.js";
+import { statusPorcelain } from "../git/operations.js";
 import { loadPipelineOutcome } from "./loadPipeline.js";
 import { afterCompletionForStage, loadStageOutcome } from "./loadStage.js";
 import { withLegacyYamlAllowedAsync } from "./legacyYaml.js";
@@ -104,11 +105,10 @@ function verifyFingerprint(items) {
 }
 function gitToplevel(cwd) {
     try {
-        return execFileSync("git", ["rev-parse", "--show-toplevel"], {
+        return runGitSync({
             cwd,
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "ignore"],
-        }).trim();
+            args: ["rev-parse", "--show-toplevel"],
+        }).stdout.trim();
     }
     catch {
         return null;
@@ -119,12 +119,7 @@ export function fileDirtyVsHead(absPath) {
     if (top === null)
         return true;
     try {
-        const status = execFileSync("git", ["status", "--porcelain", "--", absPath], {
-            cwd: top,
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "ignore"],
-        });
-        return status.trim().length > 0;
+        return statusPorcelain(top, absPath).trim().length > 0;
     }
     catch {
         return true;

package/dist/config/multiProjectCatalog.d.ts

@@ -0,0 +1,30 @@
+import { type PipelineListing, type TaskListing } from "./browseCatalog.js";
+import { type CatalogRoot, type ResolveCatalogRootsOptions } from "./resolveCatalogRoots.js";
+export type CatalogRootError = {
+    project_root: string;
+    code: "catalog_root_unreadable" | "unknown_project_root";
+    message: string;
+};
+export type MultiProjectListResult<T> = {
+    items: T[];
+    root_errors: CatalogRootError[];
+    roots: CatalogRoot[];
+};
+export declare function listPipelinesMultiProject(options: ResolveCatalogRootsOptions & {
+    projectRootFilter?: string;
+}): Promise<MultiProjectListResult<PipelineListing & {
+    project_root: string;
+}>>;
+export declare function listTasksMultiProject(options: ResolveCatalogRootsOptions & {
+    projectRootFilter?: string;
+}): Promise<MultiProjectListResult<TaskListing & {
+    project_root: string;
+}>>;
+export declare function listModelsMultiProject(options: ResolveCatalogRootsOptions & {
+    projectRootFilter?: string;
+}): Promise<MultiProjectListResult<{
+    id: string;
+    project_root: string;
+}> & {
+    models: string[];
+}>;