agentweaver 0.1.16 → 0.1.17

package/dist/pipeline/plugin-loader.js

@@ -0,0 +1,389 @@
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, symlinkSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { TaskRunnerError } from "../errors.js";
+import { agentweaverHome } from "../runtime/agentweaver-home.js";
+import { agentweaverConfigDir } from "../runtime/env-loader.js";
+import { createNodeRegistry } from "./node-registry.js";
+import { createExecutorRegistry } from "./registry.js";
+import { AGENTWEAVER_PLUGIN_SDK_VERSION, } from "./plugin-types.js";
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = path.resolve(MODULE_DIR, "../..");
+function projectPluginsDir(cwd) {
+    return path.join(cwd, ".agentweaver", ".plugins");
+}
+function globalPluginsDir() {
+    return path.join(agentweaverConfigDir(), ".plugins");
+}
+function sdkPackageRoot() {
+    return agentweaverHome(PACKAGE_ROOT);
+}
+function sdkAliasPath(pluginRoot) {
+    return path.join(pluginRoot, "node_modules", "agentweaver");
+}
+function ensurePluginSdkAlias(pluginRoot) {
+    const aliasPath = sdkAliasPath(pluginRoot);
+    const targetPath = sdkPackageRoot();
+    mkdirSync(path.dirname(aliasPath), { recursive: true });
+    if (!existsSync(aliasPath)) {
+        symlinkSync(targetPath, aliasPath, process.platform === "win32" ? "junction" : "dir");
+        return;
+    }
+    const existing = lstatSync(aliasPath);
+    if (!existing.isSymbolicLink()) {
+        throw new TaskRunnerError(`Plugin installation '${pluginRoot}' has ${aliasPath}, but it is not a symlink. Remove it so AgentWeaver can expose agentweaver/plugin-sdk.`);
+    }
+    const resolvedTarget = path.resolve(path.dirname(aliasPath), readlinkSync(aliasPath));
+    if (resolvedTarget !== targetPath) {
+        throw new TaskRunnerError(`Plugin installation '${pluginRoot}' points ${aliasPath} to ${resolvedTarget}, expected ${targetPath}. Remove it and retry.`);
+    }
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isPositiveInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((candidate) => typeof candidate === "string" && candidate.trim().length > 0);
+}
+function normalizeExecutorRouting(value, pluginId, pathLabel) {
+    if (!isPlainObject(value)) {
+        throw new TaskRunnerError(`Plugin '${pluginId}' executor routing at ${pathLabel} must be an object.`);
+    }
+    if (value["kind"] !== "llm") {
+        throw new TaskRunnerError(`Plugin '${pluginId}' executor routing at ${pathLabel} must use kind 'llm'.`);
+    }
+    const defaultModel = typeof value["defaultModel"] === "string" ? value["defaultModel"].trim() : "";
+    const models = value["models"];
+    if (!defaultModel) {
+        throw new TaskRunnerError(`Plugin '${pluginId}' executor routing at ${pathLabel} must define a non-empty defaultModel.`);
+    }
+    if (!isStringArray(models)) {
+        throw new TaskRunnerError(`Plugin '${pluginId}' executor routing at ${pathLabel} must define a non-empty string[] models.`);
+    }
+    if (!models.includes(defaultModel)) {
+        throw new TaskRunnerError(`Plugin '${pluginId}' executor routing at ${pathLabel} must include defaultModel '${defaultModel}' in models.`);
+    }
+    return {
+        kind: "llm",
+        defaultModel,
+        models: [...models],
+    };
+}
+function assertJsonSerializable(value, pluginId, pathLabel) {
+    const seen = new Set();
+    const visit = (candidate, candidatePath) => {
+        if (candidate === null ||
+            typeof candidate === "string" ||
+            typeof candidate === "number" ||
+            typeof candidate === "boolean") {
+            return;
+        }
+        if (Array.isArray(candidate)) {
+            candidate.forEach((item, index) => visit(item, `${candidatePath}[${index}]`));
+            return;
+        }
+        if (typeof candidate === "object") {
+            if (seen.has(candidate)) {
+                throw new TaskRunnerError(`Plugin '${pluginId}' has circular defaultConfig at ${pathLabel} (${candidatePath}).`);
+            }
+            seen.add(candidate);
+            for (const [key, item] of Object.entries(candidate)) {
+                visit(item, `${candidatePath}.${key}`);
+            }
+            seen.delete(candidate);
+            return;
+        }
+        throw new TaskRunnerError(`Plugin '${pluginId}' has non-JSON-serializable defaultConfig at ${pathLabel} (${candidatePath}).`);
+    };
+    visit(value, pathLabel);
+}
+function parseManifest(manifestPath, directoryName) {
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
+    }
+    catch (error) {
+        throw new TaskRunnerError(`Failed to parse plugin manifest ${manifestPath}: ${error.message}`);
+    }
+    if (!isPlainObject(parsed)) {
+        throw new TaskRunnerError(`Plugin manifest ${manifestPath} must contain a JSON object.`);
+    }
+    const manifest = parsed;
+    const id = typeof manifest["id"] === "string" ? manifest["id"].trim() : "";
+    const entrypoint = typeof manifest["entrypoint"] === "string" ? manifest["entrypoint"].trim() : "";
+    const sdkVersion = manifest["sdk_version"];
+    if (!id) {
+        throw new TaskRunnerError(`Plugin manifest ${manifestPath} must define a non-empty 'id'.`);
+    }
+    if (!isPositiveInteger(sdkVersion)) {
+        throw new TaskRunnerError(`Plugin '${id}' manifest ${manifestPath} must define a positive integer 'sdk_version'.`);
+    }
+    if (!entrypoint) {
+        throw new TaskRunnerError(`Plugin '${id}' manifest ${manifestPath} must define a non-empty 'entrypoint'.`);
+    }
+    if (id !== directoryName) {
+        throw new TaskRunnerError(`Plugin manifest id '${id}' does not match installation directory '${directoryName}' at ${manifestPath}.`);
+    }
+    if (sdkVersion !== AGENTWEAVER_PLUGIN_SDK_VERSION) {
+        throw new TaskRunnerError(`Plugin '${id}' manifest ${manifestPath} declares sdk_version ${sdkVersion}, but AgentWeaver supports ${AGENTWEAVER_PLUGIN_SDK_VERSION}.`);
+    }
+    return {
+        id,
+        sdk_version: sdkVersion,
+        entrypoint,
+        ...(typeof manifest["name"] === "string" ? { name: manifest["name"] } : {}),
+        ...(typeof manifest["version"] === "string" ? { version: manifest["version"] } : {}),
+        ...(typeof manifest["description"] === "string" ? { description: manifest["description"] } : {}),
+    };
+}
+function resolveEntrypoint(pluginRoot, manifestPath, manifest) {
+    const entrypointPath = path.resolve(path.dirname(manifestPath), manifest.entrypoint);
+    const relative = path.relative(pluginRoot, entrypointPath);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new TaskRunnerError(`Plugin '${manifest.id}' manifest ${manifestPath} resolves entrypoint outside plugin root ${pluginRoot}: ${entrypointPath}.`);
+    }
+    const extension = path.extname(entrypointPath);
+    if (extension !== ".js" && extension !== ".mjs") {
+        throw new TaskRunnerError(`Plugin '${manifest.id}' manifest ${manifestPath} must point to an ESM .js or .mjs entrypoint, got '${manifest.entrypoint}'.`);
+    }
+    return entrypointPath;
+}
+async function loadPluginModule(manifest, manifestPath, entrypointPath) {
+    try {
+        ensurePluginSdkAlias(path.dirname(manifestPath));
+        const namespace = await import(pathToFileURL(entrypointPath).href);
+        if ("default" in namespace) {
+            throw new TaskRunnerError(`Plugin '${manifest.id}' manifest ${manifestPath} must use named exports only; default exports are not supported.`);
+        }
+        return namespace;
+    }
+    catch (error) {
+        if (error instanceof TaskRunnerError) {
+            throw error;
+        }
+        throw new TaskRunnerError(`Failed to load plugin '${manifest.id}' entrypoint ${entrypointPath} from ${manifestPath}: ${error.message}`);
+    }
+}
+function validatePromptMode(value, pluginId, pathLabel) {
+    if (value === "required" || value === "allowed" || value === "forbidden") {
+        return value;
+    }
+    throw new TaskRunnerError(`Plugin '${pluginId}' has invalid prompt mode at ${pathLabel}.`);
+}
+function normalizeExecutorRegistration(candidate, index, manifest, manifestPath, entrypointPath) {
+    const pathLabel = `executors[${index}]`;
+    if (!isPlainObject(candidate)) {
+        throw new TaskRunnerError(`Plugin '${manifest.id}' registration ${pathLabel} must be an object.`);
+    }
+    const id = typeof candidate["id"] === "string" ? candidate["id"].trim() : "";
+    const definition = candidate["definition"];
+    if (!id) {
+        throw new TaskRunnerError(`Plugin '${manifest.id}' registration ${pathLabel} must define a non-empty 'id'.`);
+    }
+    if (!isPlainObject(definition)) {
+        throw new TaskRunnerError(`Plugin '${manifest.id}' executor '${id}' must define an object 'definition'.`);
+    }
+    if (definition["kind"] !== id) {
+        throw new TaskRunnerError(`Plugin '${manifest.id}' executor '${id}' must match definition.kind.`);
+    }
+    if (!isPositiveInteger(definition["version"])) {
+        throw new TaskRunnerError(`Plugin '${manifest.id}' executor '${id}' must define a positive integer definition.version.`);
+    }
+    if (typeof definition["execute"] !== "function") {
+        throw new TaskRunnerError(`Plugin '${manifest.id}' executor '${id}' must define a function definition.execute.`);
+    }
+    assertJsonSerializable(definition["defaultConfig"], manifest.id, `${pathLabel}.definition.defaultConfig`);
+    return {
+        type: "executor",
+        id,
+        pluginId: manifest.id,
+        manifestPath,
+        entrypointPath,
+        definition: definition,
+        ...(candidate["routing"] !== undefined
+            ? { routing: normalizeExecutorRouting(candidate["routing"], manifest.id, `${pathLabel}.routing`) }
+            : {}),
+    };
+}
+function normalizeNodeMetadata(metadata, id, pluginId, pathLabel) {
+    if (metadata["kind"] !== id) {
+        throw new TaskRunnerError(`Plugin '${pluginId}' node '${id}' must match metadata.kind.`);
+    }
+    if (!isPositiveInteger(metadata["version"])) {
+        throw new TaskRunnerError(`Plugin '${pluginId}' node '${id}' must define a positive integer metadata.version.`);
+    }
+    const normalized = {
+        kind: id,
+        version: metadata["version"],
+        prompt: validatePromptMode(metadata["prompt"], pluginId, `${pathLabel}.prompt`),
+    };
+    if (metadata["requiredParams"] !== undefined) {
+        if (!isStringArray(metadata["requiredParams"])) {
+            throw new TaskRunnerError(`Plugin '${pluginId}' node '${id}' must define requiredParams as string[].`);
+        }
+        normalized.requiredParams = metadata["requiredParams"];
+    }
+    if (metadata["executors"] !== undefined) {
+        if (!isStringArray(metadata["executors"])) {
+            throw new TaskRunnerError(`Plugin '${pluginId}' node '${id}' must define executors as string[].`);
+        }
+        normalized.executors = metadata["executors"];
+    }
+    if (metadata["nestedFlowParam"] !== undefined) {
+        if (typeof metadata["nestedFlowParam"] !== "string" || metadata["nestedFlowParam"].trim().length === 0) {
+            throw new TaskRunnerError(`Plugin '${pluginId}' node '${id}' must define nestedFlowParam as a non-empty string.`);
+        }
+        normalized.nestedFlowParam = metadata["nestedFlowParam"];
+    }
+    return normalized;
+}
+function normalizeNodeRegistration(candidate, index, manifest, manifestPath, entrypointPath) {
+    const pathLabel = `nodes[${index}]`;
+    if (!isPlainObject(candidate)) {
+        throw new TaskRunnerError(`Plugin '${manifest.id}' registration ${pathLabel} must be an object.`);
+    }
+    const id = typeof candidate["id"] === "string" ? candidate["id"].trim() : "";
+    const definition = candidate["definition"];
+    const metadata = candidate["metadata"];
+    if (!id) {
+        throw new TaskRunnerError(`Plugin '${manifest.id}' registration ${pathLabel} must define a non-empty 'id'.`);
+    }
+    if (!isPlainObject(definition)) {
+        throw new TaskRunnerError(`Plugin '${manifest.id}' node '${id}' must define an object 'definition'.`);
+    }
+    if (!isPlainObject(metadata)) {
+        throw new TaskRunnerError(`Plugin '${manifest.id}' node '${id}' must define an object 'metadata'.`);
+    }
+    if (definition["kind"] !== id) {
+        throw new TaskRunnerError(`Plugin '${manifest.id}' node '${id}' must match definition.kind.`);
+    }
+    if (!isPositiveInteger(definition["version"])) {
+        throw new TaskRunnerError(`Plugin '${manifest.id}' node '${id}' must define a positive integer definition.version.`);
+    }
+    if (typeof definition["run"] !== "function") {
+        throw new TaskRunnerError(`Plugin '${manifest.id}' node '${id}' must define a function definition.run.`);
+    }
+    const normalizedMetadata = normalizeNodeMetadata(metadata, id, manifest.id, `${pathLabel}.metadata`);
+    if (definition["version"] !== normalizedMetadata.version) {
+        throw new TaskRunnerError(`Plugin '${manifest.id}' node '${id}' must use the same version in definition and metadata.`);
+    }
+    return {
+        type: "node",
+        id,
+        pluginId: manifest.id,
+        manifestPath,
+        entrypointPath,
+        definition: definition,
+        metadata: normalizedMetadata,
+    };
+}
+function normalizePluginModule(manifest, manifestPath, entrypointPath, namespace) {
+    const executorsValue = namespace["executors"];
+    const nodesValue = namespace["nodes"];
+    if (executorsValue !== undefined && !Array.isArray(executorsValue)) {
+        throw new TaskRunnerError(`Plugin '${manifest.id}' manifest ${manifestPath} must export 'executors' as an array.`);
+    }
+    if (nodesValue !== undefined && !Array.isArray(nodesValue)) {
+        throw new TaskRunnerError(`Plugin '${manifest.id}' manifest ${manifestPath} must export 'nodes' as an array.`);
+    }
+    const executorItems = executorsValue ?? [];
+    const nodeItems = nodesValue ?? [];
+    if (executorsValue === undefined && nodesValue === undefined) {
+        throw new TaskRunnerError(`Plugin '${manifest.id}' manifest ${manifestPath} must export named 'executors' and/or 'nodes' arrays.`);
+    }
+    if (executorItems.length === 0 && nodeItems.length === 0) {
+        throw new TaskRunnerError(`Plugin '${manifest.id}' manifest ${manifestPath} must export at least one non-empty recognized registration array.`);
+    }
+    return {
+        manifest,
+        manifestPath,
+        entrypointPath,
+        executors: executorItems.map((candidate, index) => normalizeExecutorRegistration(candidate, index, manifest, manifestPath, entrypointPath)),
+        nodes: nodeItems.map((candidate, index) => normalizeNodeRegistration(candidate, index, manifest, manifestPath, entrypointPath)),
+    };
+}
+async function discoverPluginsFromRoot(pluginsRoot) {
+    if (!existsSync(pluginsRoot)) {
+        return [];
+    }
+    const entries = readdirSync(pluginsRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .sort((left, right) => left.name.localeCompare(right.name));
+    const plugins = [];
+    for (const entry of entries) {
+        const pluginRoot = path.join(pluginsRoot, entry.name);
+        const manifestPath = path.join(pluginRoot, "plugin.json");
+        if (!existsSync(manifestPath)) {
+            throw new TaskRunnerError(`Plugin installation '${entry.name}' is missing manifest ${manifestPath}.`);
+        }
+        const manifest = parseManifest(manifestPath, entry.name);
+        const entrypointPath = resolveEntrypoint(pluginRoot, manifestPath, manifest);
+        const namespace = await loadPluginModule(manifest, manifestPath, entrypointPath);
+        plugins.push(normalizePluginModule(manifest, manifestPath, entrypointPath, namespace));
+    }
+    return plugins;
+}
+export async function discoverProjectPlugins(cwd) {
+    return discoverPluginsFromRoot(projectPluginsDir(cwd));
+}
+export async function discoverGlobalPlugins() {
+    return discoverPluginsFromRoot(globalPluginsDir());
+}
+function validateUniquePluginIds(plugins) {
+    const byId = new Map();
+    for (const plugin of plugins) {
+        const duplicate = byId.get(plugin.manifest.id);
+        if (duplicate) {
+            throw new TaskRunnerError(`Duplicate plugin id '${plugin.manifest.id}' conflicts between ${duplicate.manifestPath} and ${plugin.manifestPath}.`);
+        }
+        byId.set(plugin.manifest.id, plugin);
+    }
+}
+function cacheKeyForPlugins(cwd, plugins) {
+    if (plugins.length === 0) {
+        return `built-in:${path.resolve(cwd)}`;
+    }
+    const suffix = plugins
+        .map((plugin) => `${plugin.manifest.id}@${plugin.manifestPath}:${plugin.entrypointPath}`)
+        .join("|");
+    return `plugins:${path.resolve(cwd)}:${suffix}`;
+}
+function validatePluginNodeDependencies(plugins, executorRegistry) {
+    for (const plugin of plugins) {
+        for (const node of plugin.nodes) {
+            for (const executorId of node.metadata.executors ?? []) {
+                if (!executorRegistry.has(executorId)) {
+                    throw new TaskRunnerError(`Plugin '${plugin.manifest.id}' node '${node.id}' requires unknown executor '${executorId}'.`);
+                }
+            }
+        }
+    }
+}
+export async function createPipelineRegistryContext(cwd) {
+    const plugins = [
+        ...await discoverGlobalPlugins(),
+        ...await discoverProjectPlugins(cwd),
+    ];
+    validateUniquePluginIds(plugins);
+    const executorRegistry = createExecutorRegistry(plugins.flatMap((plugin) => plugin.executors));
+    const nodeRegistry = createNodeRegistry(plugins.flatMap((plugin) => plugin.nodes));
+    validatePluginNodeDependencies(plugins, executorRegistry);
+    return {
+        cwd: path.resolve(cwd),
+        cacheKey: cacheKeyForPlugins(cwd, plugins),
+        executors: executorRegistry,
+        nodes: nodeRegistry,
+        plugins,
+    };
+}
+export function createBuiltInRegistryContext(cwd) {
+    return {
+        cwd: path.resolve(cwd),
+        cacheKey: `built-in:${path.resolve(cwd)}`,
+        executors: createExecutorRegistry(),
+        nodes: createNodeRegistry(),
+        plugins: [],
+    };
+}

package/dist/pipeline/plugin-types.js

@@ -0,0 +1 @@
+export const AGENTWEAVER_PLUGIN_SDK_VERSION = 1;

package/dist/pipeline/registry.js

@@ -7,6 +7,18 @@ import { jiraFetchExecutor } from "../executors/jira-fetch-executor.js";
 import { opencodeExecutor } from "../executors/opencode-executor.js";
 import { processExecutor } from "../executors/process-executor.js";
 import { telegramNotifierExecutor } from "../executors/telegram-notifier-executor.js";
+import { TaskRunnerError } from "../errors.js";
+export const BUILT_IN_EXECUTOR_IDS = [
+    "process",
+    "command-check",
+    "fetch-gitlab-diff",
+    "fetch-gitlab-review",
+    "git-commit",
+    "jira-fetch",
+    "codex",
+    "opencode",
+    "telegram-notifier",
+];
 const builtInExecutors = {
     process: processExecutor,
     "command-check": commandCheckExecutor,
@@ -18,16 +30,71 @@ const builtInExecutors = {
     opencode: opencodeExecutor,
     "telegram-notifier": telegramNotifierExecutor,
 };
-export function createExecutorRegistry() {
+const builtInExecutorRouting = {
+    codex: {
+        kind: "llm",
+        defaultModel: "gpt-5.5",
+        models: ["gpt-5.5", "gpt-5.4", "gpt-5.4-mini", "gpt-5.3-codex"],
+    },
+    opencode: {
+        kind: "llm",
+        defaultModel: "minimax-coding-plan/MiniMax-M2.7",
+        models: [
+            "opencode/minimax-m2.5-free",
+            "minimax-coding-plan/MiniMax-M2.7",
+            "zhipuai-coding-plan/glm-5.1",
+            "zhipuai-coding-plan/glm-4.7",
+        ],
+    },
+};
+function coreOwner(id) {
+    return {
+        kind: "core",
+        id: `core:${id}`,
+        manifestPath: "built-in executor registry",
+    };
+}
+export function createExecutorRegistry(pluginExecutors = []) {
+    const definitions = new Map(Object.entries(builtInExecutors));
+    const routing = new Map(Object.entries(builtInExecutorRouting).map(([id, definition]) => [id, definition]));
+    const owners = new Map(Object.keys(builtInExecutors).map((id) => [id, coreOwner(id)]));
+    for (const registration of pluginExecutors) {
+        const existingOwner = owners.get(registration.id);
+        if (existingOwner) {
+            throw new TaskRunnerError(`Duplicate executor id '${registration.id}' conflicts between ${existingOwner.id} (${existingOwner.manifestPath}) and plugin '${registration.pluginId}' (${registration.manifestPath}).`);
+        }
+        definitions.set(registration.id, registration.definition);
+        if (registration.routing) {
+            routing.set(registration.id, registration.routing);
+        }
+        owners.set(registration.id, {
+            kind: "plugin",
+            id: registration.pluginId,
+            manifestPath: registration.manifestPath,
+            entrypointPath: registration.entrypointPath,
+        });
+    }
     return {
         get(id) {
-            return builtInExecutors[id];
+            const definition = definitions.get(id);
+            if (!definition) {
+                throw new TaskRunnerError(`Unknown executor '${id}'.`);
+            }
+            return definition;
         },
         has(id) {
-            return id in builtInExecutors;
+            return definitions.has(id);
         },
         ids() {
-            return Object.keys(builtInExecutors);
+            return [...definitions.keys()];
+        },
+        getRouting(id) {
+            return routing.get(id) ?? null;
+        },
+        llmExecutors() {
+            return [...routing.entries()]
+                .filter((entry) => entry[1].kind === "llm")
+                .map(([id, definition]) => ({ id, routing: definition }));
         },
     };
 }

package/dist/pipeline/spec-compiler.js

@@ -21,6 +21,7 @@ function interpolateValueSpec(value, repeatVars) {
                 artifactList: {
                     ...value.artifactList,
                     taskKey: interpolateValueSpec(value.artifactList.taskKey, repeatVars),
+                    ...(value.artifactList.iteration ? { iteration: interpolateValueSpec(value.artifactList.iteration, repeatVars) } : {}),
                 },
             };
         }

package/dist/pipeline/spec-loader.js

@@ -2,6 +2,7 @@ import { existsSync, readdirSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { TaskRunnerError } from "../errors.js";
+import { agentweaverConfigDir } from "../runtime/env-loader.js";
 const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 const BUILT_IN_FLOW_SPECS_DIR = path.join(MODULE_DIR, "flow-specs");
 function parseFlowSpec(filePath) {
@@ -18,6 +19,9 @@ export function resolveBuiltInFlowSpecPath(fileName) {
 export function projectFlowSpecsDir(cwd) {
     return path.join(cwd, ".agentweaver", ".flows");
 }
+export function globalFlowSpecsDir() {
+    return path.join(agentweaverConfigDir(), ".flows");
+}
 export function listBuiltInFlowSpecFiles() {
     if (!existsSync(BUILT_IN_FLOW_SPECS_DIR)) {
         return [];
@@ -48,6 +52,13 @@ export function listProjectFlowSpecFiles(cwd) {
     }
     return collectJsonFilesRecursively(directory);
 }
+export function listGlobalFlowSpecFiles() {
+    const directory = globalFlowSpecsDir();
+    if (!existsSync(directory)) {
+        return [];
+    }
+    return collectJsonFilesRecursively(directory);
+}
 export function loadFlowSpecSync(source) {
     return parseFlowSpec(source.source === "built-in" ? resolveBuiltInFlowSpecPath(source.fileName) : source.filePath);
 }
@@ -57,3 +68,6 @@ export function loadBuiltInFlowSpecSync(fileName) {
 export function loadProjectFlowSpecSync(filePath) {
     return loadFlowSpecSync({ source: "project-local", filePath });
 }
+export function loadGlobalFlowSpecSync(filePath) {
+    return loadFlowSpecSync({ source: "global", filePath });
+}

package/dist/pipeline/spec-validator.js

@@ -19,6 +19,9 @@ function validateArtifactRefSpec(spec, path) {
 function validateArtifactListRefSpec(spec, path) {
     assert(isArtifactListRefKind(spec.kind), `Unknown artifact list kind '${spec.kind}' at ${path}.kind`);
     validateValueSpec(spec.taskKey, `${path}.taskKey`);
+    if (spec.iteration) {
+        validateValueSpec(spec.iteration, `${path}.iteration`);
+    }
 }
 function assert(condition, message) {
     if (!condition) {
@@ -241,6 +244,9 @@ function validateExpandedValueSpec(value, phases, currentPhaseIndex, currentStep
     }
     if ("artifactList" in value) {
         validateExpandedValueSpec(value.artifactList.taskKey, phases, currentPhaseIndex, currentStepIndex, `${path}.artifactList.taskKey`, allowCurrentStepRef);
+        if (value.artifactList.iteration) {
+            validateExpandedValueSpec(value.artifactList.iteration, phases, currentPhaseIndex, currentStepIndex, `${path}.artifactList.iteration`, allowCurrentStepRef);
+        }
         return;
     }
     if ("template" in value) {

package/dist/pipeline/value-resolver.js

@@ -211,11 +211,12 @@ function resolveArtifact(spec, context) {
 }
 function resolveArtifactList(spec, context) {
     const taskKey = String(resolveValue(spec.taskKey, context));
+    const iteration = spec.iteration === undefined ? undefined : Number(resolveValue(spec.iteration, context));
     switch (spec.kind) {
         case "bug-analyze-artifacts":
             return bugAnalyzeArtifacts(taskKey);
         case "plan-artifacts":
-            return planArtifacts(taskKey);
+            return planArtifacts(taskKey, iteration);
     }
 }
 export function resolveValue(value, context) {

package/dist/plugin-sdk.js

@@ -0,0 +1 @@
+export { AGENTWEAVER_PLUGIN_SDK_VERSION } from "./pipeline/plugin-types.js";

package/dist/runtime/artifact-registry.js

@@ -81,6 +81,9 @@ function collectManifestFiles(rootDir) {
         for (const entry of entries) {
             const fullPath = path.join(current, entry.name);
             if (entry.isDirectory()) {
+                if (entry.name === "restart-archives") {
+                    continue;
+                }
                 queue.push(fullPath);
                 continue;
             }