@getforgeai/cli 0.1.0-beta.1

package/dist/mcp/tools/forge-remove-group-dependency.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { McpSessionContext } from "../types.js";
+export declare function registerForgeRemoveGroupDependency(server: McpServer, context: McpSessionContext): void;
+//# sourceMappingURL=forge-remove-group-dependency.d.ts.map

package/dist/mcp/tools/forge-remove-group-dependency.js

@@ -0,0 +1,19 @@
+import { ForgeRemoveGroupDependencyInputSchema } from "@getforgeai/protocol";
+import { executeSocketEmit } from "../mcp-response.js";
+const shape = ForgeRemoveGroupDependencyInputSchema.shape;
+export function registerForgeRemoveGroupDependency(server, context) {
+    server.registerTool("forge_remove_group_dependency", {
+        description: "Remove a dependency between two task groups. References groups by name (most recently created match).",
+        inputSchema: {
+            groupName: shape.groupName.describe("Name of the blocked group (the one that depends on the other)"),
+            dependsOnGroupName: shape.dependsOnGroupName.describe("Name of the blocking group (the one it depends on)"),
+        },
+    }, async (params) => {
+        return executeSocketEmit(context, "remove group dependency", () => context.socketClient.emitMcpTaskGroupRemoveDependency({
+            projectId: context.projectId,
+            groupName: params.groupName,
+            dependsOnGroupName: params.dependsOnGroupName,
+        }));
+    });
+}
+//# sourceMappingURL=forge-remove-group-dependency.js.map

package/dist/mcp/tools/forge-remove-task-dependency.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { McpSessionContext } from "../types.js";
+export declare function registerForgeRemoveTaskDependency(server: McpServer, context: McpSessionContext): void;
+//# sourceMappingURL=forge-remove-task-dependency.d.ts.map

package/dist/mcp/tools/forge-remove-task-dependency.js

@@ -0,0 +1,19 @@
+import { ForgeRemoveTaskDependencyInputSchema } from "@getforgeai/protocol";
+import { executeSocketEmit } from "../mcp-response.js";
+const shape = ForgeRemoveTaskDependencyInputSchema.shape;
+export function registerForgeRemoveTaskDependency(server, context) {
+    server.registerTool("forge_remove_task_dependency", {
+        description: "Remove a dependency between two tasks. References tasks by title (most recently created match).",
+        inputSchema: {
+            taskName: shape.taskName.describe("Title of the blocked task (the one that depends on the other)"),
+            dependsOnTaskName: shape.dependsOnTaskName.describe("Title of the blocking task (the one it depends on)"),
+        },
+    }, async (params) => {
+        return executeSocketEmit(context, "remove task dependency", () => context.socketClient.emitMcpTaskRemoveDependency({
+            projectId: context.projectId,
+            taskName: params.taskName,
+            dependsOnTaskName: params.dependsOnTaskName,
+        }));
+    });
+}
+//# sourceMappingURL=forge-remove-task-dependency.js.map

package/dist/mcp/tools/forge-requeue.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { McpSessionContext } from "../types.js";
+export declare function registerForgeRequeue(server: McpServer, context: McpSessionContext): void;
+//# sourceMappingURL=forge-requeue.d.ts.map

package/dist/mcp/tools/forge-requeue.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { mcpSuccess, mcpError, handleRestError } from "../mcp-response.js";
+export function registerForgeRequeue(server, context) {
+    server.registerTool("forge_requeue", {
+        description: "Re-queue the current task to be re-dispatched on the same column. Returns { allowed, count, max }. If allowed=false (max reached), decide: call forge_ask_human or skip to next gate.",
+        inputSchema: {
+            taskId: z.string().min(1).describe("Task ID to re-queue"),
+            reason: z
+                .string()
+                .optional()
+                .describe("Optional reason for re-queue (e.g., review feedback)"),
+        },
+    }, async ({ taskId, reason }) => {
+        // Check current task status to reject if still in dispatch queue
+        let currentTask;
+        try {
+            currentTask = await context.restClient.getTask(taskId);
+        }
+        catch (error) {
+            return handleRestError(error, taskId);
+        }
+        // Reject if not yet dispatched — task is already in the queue
+        if (!currentTask.kanbanSubStatus) {
+            return mcpError({
+                error: "INVALID_STATUS",
+                message: "Task has not been dispatched yet. It is already in the dispatch queue.",
+            });
+        }
+        // Call REST endpoint for requeue
+        try {
+            const result = await context.restClient.requeueTask(taskId, reason);
+            return mcpSuccess(result);
+        }
+        catch (error) {
+            return handleRestError(error, taskId);
+        }
+    });
+}
+//# sourceMappingURL=forge-requeue.js.map

package/dist/mcp/tools/forge-submit-pr.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { McpSessionContext } from "../types.js";
+export declare function registerForgeSubmitPr(server: McpServer, context: McpSessionContext): void;
+//# sourceMappingURL=forge-submit-pr.d.ts.map

package/dist/mcp/tools/forge-submit-pr.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import { MCP_ERROR_CODE } from "../types.js";
+export function registerForgeSubmitPr(server, context) {
+    server.tool("forge_submit_pr", "Register a pull request on the ForgeAI board. Cloud tracks the PR and returns a tracking ID.", {
+        taskId: z.string().min(1).describe("Task ID the PR belongs to"),
+        prTitle: z.string().min(1).describe("Pull request title"),
+        baseBranch: z
+            .string()
+            .min(1)
+            .describe("Base branch for the pull request"),
+        description: z.string().min(1).describe("Pull request description"),
+    }, async ({ taskId, prTitle, baseBranch, description }) => {
+        try {
+            if (!context.socketClient.socket.connected) {
+                return {
+                    isError: true,
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                error: MCP_ERROR_CODE.NETWORK_ERROR,
+                                message: "Socket.io not connected. Cannot submit PR.",
+                                retryHint: "Wait for reconnection and retry.",
+                            }),
+                        },
+                    ],
+                };
+            }
+            context.socketClient.emitTaskSubmitPr({
+                taskId,
+                prTitle,
+                baseBranch,
+                description,
+                projectId: context.projectId,
+            });
+            // Generate a tracking ID (Cloud will associate this with the task)
+            const prTrackingId = `pr-${taskId}-${Date.now()}`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            taskId,
+                            prTrackingId,
+                            success: true,
+                        }),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: MCP_ERROR_CODE.NETWORK_ERROR,
+                            message: error instanceof Error ? error.message : String(error),
+                            retryHint: "Retry in a few seconds.",
+                        }),
+                    },
+                ],
+            };
+        }
+    });
+}
+//# sourceMappingURL=forge-submit-pr.js.map

package/dist/mcp/tools/forge-update-status.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { McpSessionContext } from "../types.js";
+export declare function registerForgeUpdateStatus(server: McpServer, context: McpSessionContext): void;
+//# sourceMappingURL=forge-update-status.d.ts.map

package/dist/mcp/tools/forge-update-status.js

@@ -0,0 +1,77 @@
+import { z } from "zod";
+import { KANBAN_SUB_STATUS } from "@getforgeai/protocol";
+import { mcpSuccess, mcpError, mcpNetworkError, handleRestError, } from "../mcp-response.js";
+/** Valid kanbanSubStatus transitions (from → Set of valid targets) */
+const VALID_TRANSITIONS = {
+    WAITING: ["ACTIVE"],
+    ACTIVE: ["DONE", "AWAITING_HUMAN"],
+    AWAITING_HUMAN: ["ACTIVE"],
+    PENDING_CORRECTION: ["ACTIVE"],
+    DONE: [],
+};
+export function registerForgeUpdateStatus(server, context) {
+    server.registerTool("forge_update_status", {
+        description: "Update a task's status in ForgeAI. Validates against the task state machine before applying.",
+        inputSchema: {
+            taskId: z.string().min(1).describe("Task ID to update"),
+            kanbanSubStatus: z
+                .enum(KANBAN_SUB_STATUS)
+                .describe("New kanban sub-status to set"),
+        },
+    }, async ({ taskId, kanbanSubStatus: newSubStatus }) => {
+        // Fetch current task to validate transition
+        let currentTask;
+        try {
+            currentTask = await context.restClient.getTask(taskId);
+        }
+        catch (error) {
+            return handleRestError(error, taskId);
+        }
+        // Validate state transition
+        const currentSubStatus = currentTask.kanbanSubStatus ?? "WAITING";
+        const validTargets = VALID_TRANSITIONS[currentSubStatus];
+        if (!validTargets?.includes(newSubStatus)) {
+            return mcpError({
+                error: "INVALID_STATUS",
+                message: `Cannot transition from "${currentSubStatus}" to "${newSubStatus}"`,
+                validTransitions: validTargets ?? [],
+            });
+        }
+        // Try Socket.io first for real-time propagation
+        try {
+            if (context.socketClient.socket.connected) {
+                context.socketClient.emitTaskUpdate({
+                    taskId,
+                    kanbanSubStatus: newSubStatus,
+                    projectId: context.projectId,
+                });
+                return mcpSuccess({
+                    taskId,
+                    previousSubStatus: currentSubStatus,
+                    newSubStatus,
+                    success: true,
+                });
+            }
+        }
+        catch {
+            // Socket.io failed, fall through to REST
+        }
+        // Fallback to REST
+        try {
+            await context.restClient.updateTaskSubStatus({
+                taskId,
+                kanbanSubStatus: newSubStatus,
+            });
+            return mcpSuccess({
+                taskId,
+                previousSubStatus: currentSubStatus,
+                newSubStatus,
+                success: true,
+            });
+        }
+        catch (error) {
+            return mcpNetworkError(error, "Both Socket.io and REST failed. Retry in a few seconds.");
+        }
+    });
+}
+//# sourceMappingURL=forge-update-status.js.map

package/dist/mcp/tools/forge-update-task-group.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { McpSessionContext } from "../types.js";
+export declare function registerForgeUpdateTaskGroup(server: McpServer, context: McpSessionContext): void;
+//# sourceMappingURL=forge-update-task-group.d.ts.map

package/dist/mcp/tools/forge-update-task-group.js

@@ -0,0 +1,21 @@
+import { ForgeUpdateTaskGroupInputSchema } from "@getforgeai/protocol";
+import { executeSocketEmit } from "../mcp-response.js";
+const shape = ForgeUpdateTaskGroupInputSchema.shape;
+export function registerForgeUpdateTaskGroup(server, context) {
+    server.registerTool("forge_update_task_group", {
+        description: "Update an existing task group by name (most recently created match). Can update name and/or description.",
+        inputSchema: {
+            name: shape.name.describe("Current group name to find"),
+            newName: shape.newName.describe("New name for the group"),
+            description: shape.description.describe("New description"),
+        },
+    }, async (params) => {
+        return executeSocketEmit(context, "update task group", () => context.socketClient.emitMcpTaskGroupUpdate({
+            projectId: context.projectId,
+            name: params.name,
+            newName: params.newName,
+            description: params.description,
+        }));
+    });
+}
+//# sourceMappingURL=forge-update-task-group.js.map

package/dist/mcp/tools/forge-update-task.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { McpSessionContext } from "../types.js";
+export declare function registerForgeUpdateTask(server: McpServer, context: McpSessionContext): void;
+//# sourceMappingURL=forge-update-task.d.ts.map

package/dist/mcp/tools/forge-update-task.js

@@ -0,0 +1,25 @@
+import { ForgeUpdateTaskInputSchema } from "@getforgeai/protocol";
+import { executeSocketEmit } from "../mcp-response.js";
+const shape = ForgeUpdateTaskInputSchema.shape;
+export function registerForgeUpdateTask(server, context) {
+    server.registerTool("forge_update_task", {
+        description: "Update an existing task by name (most recently created match). Can update title, description, priority, and/or storyPoints.",
+        inputSchema: {
+            name: shape.name.describe("Current task title to find"),
+            title: shape.title.describe("New title for the task"),
+            description: shape.description.describe("New description"),
+            priority: shape.priority.describe("New priority"),
+            storyPoints: shape.storyPoints.describe("New story points estimate"),
+        },
+    }, async (params) => {
+        return executeSocketEmit(context, "update task", () => context.socketClient.emitMcpTaskUpdate({
+            projectId: context.projectId,
+            name: params.name,
+            title: params.title,
+            description: params.description,
+            priority: params.priority,
+            storyPoints: params.storyPoints,
+        }));
+    });
+}
+//# sourceMappingURL=forge-update-task.js.map

package/dist/mcp/tools/forge-validate-merge.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { McpSessionContext } from "../types.js";
+export declare function registerForgeValidateMerge(server: McpServer, _context: McpSessionContext): void;
+//# sourceMappingURL=forge-validate-merge.d.ts.map

package/dist/mcp/tools/forge-validate-merge.js

@@ -0,0 +1,194 @@
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { promisify } from "node:util";
+import { z } from "zod";
+import { mcpSuccess, mcpError } from "../mcp-response.js";
+import { MCP_ERROR_CODE } from "../types.js";
+const execFileAsync = promisify(execFile);
+/** Maximum output bytes to include in command results. */
+const MAX_OUTPUT_BYTES = 50 * 1024; // 50 KB
+/** Timeout for build/test commands (10 minutes). */
+const COMMAND_TIMEOUT_MS = 10 * 60 * 1000;
+function truncate(text, maxBytes) {
+    if (text.length <= maxBytes)
+        return text;
+    return text.slice(0, maxBytes) + "\n\n--- truncated ---";
+}
+/**
+ * Run a shell command in the given directory and return stdout + stderr.
+ * Returns the result instead of throwing, so callers can inspect output on failure.
+ */
+async function runCommand(cwd, command, args) {
+    try {
+        const { stdout, stderr } = await execFileAsync(command, args, {
+            cwd,
+            timeout: COMMAND_TIMEOUT_MS,
+            env: { ...process.env, CI: "true", NODE_ENV: "test" },
+        });
+        return { success: true, stdout: stdout.trim(), stderr: stderr.trim() };
+    }
+    catch (error) {
+        const execError = error;
+        return {
+            success: false,
+            stdout: (execError.stdout ?? "").trim(),
+            stderr: (execError.stderr ?? execError.message ?? "").trim(),
+        };
+    }
+}
+/**
+ * Detect available package manager and test command from package.json.
+ */
+async function detectCommands(repoPath) {
+    const defaults = {
+        packageManager: "pnpm",
+        installArgs: ["install", "--frozen-lockfile"],
+        buildArgs: ["build"],
+        testArgs: ["test:ci"],
+        hasPackageJson: false,
+    };
+    try {
+        const packageJsonPath = resolve(repoPath, "package.json");
+        const raw = await readFile(packageJsonPath, "utf-8");
+        const pkg = JSON.parse(raw);
+        defaults.hasPackageJson = true;
+        // Detect package manager from packageManager field or lockfile
+        if (pkg.packageManager?.startsWith("yarn")) {
+            defaults.packageManager = "yarn";
+            defaults.installArgs = ["install", "--frozen-lockfile"];
+        }
+        else if (pkg.packageManager?.startsWith("npm")) {
+            defaults.packageManager = "npm";
+            defaults.installArgs = ["ci"];
+        }
+        // Default: pnpm
+        // Detect test command
+        const scripts = pkg.scripts ?? {};
+        if (scripts["test:ci"]) {
+            defaults.testArgs = ["test:ci"];
+        }
+        else if (scripts["test"]) {
+            defaults.testArgs = ["test"];
+        }
+        else {
+            defaults.testArgs = [];
+        }
+        // Detect build command
+        if (!scripts["build"]) {
+            defaults.buildArgs = [];
+        }
+        return defaults;
+    }
+    catch {
+        return defaults;
+    }
+}
+export function registerForgeValidateMerge(server, _context) {
+    server.registerTool("forge_validate_merge", {
+        description: "Validate a merge by running install, build, and tests in the repository. Detects the package manager and test command from package.json. Returns structured results for each step (pass/fail + output).",
+        inputSchema: {
+            repoPath: z
+                .string()
+                .min(1)
+                .describe("Absolute path to the git repository to validate"),
+        },
+    }, async ({ repoPath }) => {
+        try {
+            const config = await detectCommands(repoPath);
+            if (!config.hasPackageJson) {
+                return mcpError({
+                    error: MCP_ERROR_CODE.VALIDATION_ERROR,
+                    message: `No package.json found in "${repoPath}". Cannot run validation.`,
+                    hint: "Ensure the repoPath points to a valid Node.js project root.",
+                });
+            }
+            const results = [];
+            // 1. Install dependencies
+            const installResult = await runCommand(repoPath, config.packageManager, config.installArgs);
+            results.push({
+                step: "install",
+                success: installResult.success,
+                stdout: truncate(installResult.stdout, MAX_OUTPUT_BYTES),
+                stderr: truncate(installResult.stderr, MAX_OUTPUT_BYTES),
+            });
+            if (!installResult.success) {
+                return mcpSuccess({
+                    success: false,
+                    failedStep: "install",
+                    message: `Dependency installation failed. Build and tests were skipped.`,
+                    results,
+                });
+            }
+            // 2. Build
+            if (config.buildArgs.length > 0) {
+                const buildResult = await runCommand(repoPath, config.packageManager, config.buildArgs);
+                results.push({
+                    step: "build",
+                    success: buildResult.success,
+                    stdout: truncate(buildResult.stdout, MAX_OUTPUT_BYTES),
+                    stderr: truncate(buildResult.stderr, MAX_OUTPUT_BYTES),
+                });
+                if (!buildResult.success) {
+                    return mcpSuccess({
+                        success: false,
+                        failedStep: "build",
+                        message: `Build failed. Tests were skipped.`,
+                        results,
+                    });
+                }
+            }
+            else {
+                results.push({
+                    step: "build",
+                    success: true,
+                    stdout: "",
+                    stderr: "",
+                    skipped: true,
+                });
+            }
+            // 3. Tests
+            if (config.testArgs.length > 0) {
+                const testResult = await runCommand(repoPath, config.packageManager, config.testArgs);
+                results.push({
+                    step: "test",
+                    success: testResult.success,
+                    stdout: truncate(testResult.stdout, MAX_OUTPUT_BYTES),
+                    stderr: truncate(testResult.stderr, MAX_OUTPUT_BYTES),
+                });
+                if (!testResult.success) {
+                    return mcpSuccess({
+                        success: false,
+                        failedStep: "test",
+                        message: `Tests failed.`,
+                        results,
+                    });
+                }
+            }
+            else {
+                results.push({
+                    step: "test",
+                    success: true,
+                    stdout: "",
+                    stderr: "",
+                    skipped: true,
+                });
+            }
+            // All steps passed
+            return mcpSuccess({
+                success: true,
+                message: `Validation passed: install, build, and tests all succeeded.`,
+                results,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return mcpError({
+                error: MCP_ERROR_CODE.NETWORK_ERROR,
+                message: `Unexpected error during validation: ${message}`,
+                hint: "Check that the repository path is valid and accessible.",
+            });
+        }
+    });
+}
+//# sourceMappingURL=forge-validate-merge.js.map

package/dist/mcp/types.d.ts

@@ -0,0 +1,39 @@
+import type { createRestClient } from "../lib/rest-client.js";
+import type { createSocketClient } from "../lib/socket-client.js";
+/**
+ * Session context provided to each MCP server instance.
+ * Contains references to the daemon's existing clients for Cloud relay.
+ */
+export type McpSessionContext = {
+    taskId: string;
+    projectId: string;
+    orgId: string;
+    restClient: ReturnType<typeof createRestClient>;
+    socketClient: ReturnType<typeof createSocketClient>;
+    /** Current task state — updated by resource reads */
+    currentTask: McpTaskContext | null;
+    /** Project root path for reading local files (CLAUDE.md, etc.) */
+    projectRoot: string | null;
+    /** Workflow context — set when MCP server runs in a workflow step context (Story 6b.4) */
+    workflowId?: string;
+    stepId?: string;
+};
+/** Task context served by forge://task/current resource */
+export type McpTaskContext = {
+    id: string;
+    title: string;
+    description: string;
+    status: string;
+    kanbanColumn?: string | null;
+    assigneeId?: string | null;
+    cliDeviceId?: string | null;
+};
+/** MCP error codes returned to agents */
+export declare const MCP_ERROR_CODE: {
+    readonly TASK_NOT_FOUND: "TASK_NOT_FOUND";
+    readonly NETWORK_ERROR: "NETWORK_ERROR";
+    readonly INVALID_STATUS: "INVALID_STATUS";
+    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
+};
+export type McpErrorCode = (typeof MCP_ERROR_CODE)[keyof typeof MCP_ERROR_CODE];
+//# sourceMappingURL=types.d.ts.map

package/dist/mcp/types.js

@@ -0,0 +1,8 @@
+/** MCP error codes returned to agents */
+export const MCP_ERROR_CODE = {
+    TASK_NOT_FOUND: "TASK_NOT_FOUND",
+    NETWORK_ERROR: "NETWORK_ERROR",
+    INVALID_STATUS: "INVALID_STATUS",
+    VALIDATION_ERROR: "VALIDATION_ERROR",
+};
+//# sourceMappingURL=types.js.map

package/dist/methodology/artifact-manager.d.ts

@@ -0,0 +1,14 @@
+import type { Socket } from "socket.io-client";
+import type { ClientToServerEvents, ServerToClientEvents } from "@getforgeai/protocol";
+type TypedClientSocket = Socket<ServerToClientEvents, ClientToServerEvents>;
+export type ArtifactHandlerOptions = {
+    artifactDir?: string;
+};
+/**
+ * Register artifact event handlers on a CLI socket connection.
+ * Listens for `workflow:artifact` events from Cloud, writes artifact
+ * content to the Git working tree, and emits confirmation back.
+ */
+export declare function registerArtifactHandlers(socket: TypedClientSocket, orgId: string, options?: ArtifactHandlerOptions): void;
+export {};
+//# sourceMappingURL=artifact-manager.d.ts.map

package/dist/methodology/artifact-manager.js

@@ -0,0 +1,55 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import chalk from "chalk";
+const DEFAULT_ARTIFACT_DIR = "docs/methodology";
+/**
+ * Register artifact event handlers on a CLI socket connection.
+ * Listens for `workflow:artifact` events from Cloud, writes artifact
+ * content to the Git working tree, and emits confirmation back.
+ */
+export function registerArtifactHandlers(socket, orgId, options = {}) {
+    const artifactDir = options.artifactDir ?? DEFAULT_ARTIFACT_DIR;
+    socket.on("workflow:artifact", (payload) => {
+        if (!payload.content) {
+            console.warn(chalk.yellow("[artifact] Received artifact event without content"));
+            return;
+        }
+        // Sanitize fileName to prevent path traversal (L1)
+        const rawFileName = payload.fileName || `${payload.stepKey}.md`;
+        const fileName = basename(rawFileName);
+        const filePath = join(artifactDir, fileName);
+        const absolutePath = join(process.cwd(), filePath);
+        try {
+            const dir = dirname(absolutePath);
+            if (!existsSync(dir)) {
+                mkdirSync(dir, { recursive: true });
+            }
+            writeFileSync(absolutePath, payload.content, "utf-8");
+            console.log(chalk.green(`[artifact] Written: ${filePath}`));
+            socket.emit("workflow:artifact", {
+                orgId,
+                projectId: payload.projectId,
+                workflowId: payload.workflowId,
+                stepId: payload.stepId,
+                fileName,
+                filePath,
+                artifactType: payload.artifactType,
+                stepKey: payload.stepKey,
+                timestamp: new Date().toISOString(),
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(chalk.red(`[artifact] Failed to write ${filePath}: ${message}`));
+            // Emit error event so Cloud/UI can handle the failure (H1)
+            socket.emit("workflow:artifact:error", {
+                orgId,
+                workflowId: payload.workflowId,
+                stepId: payload.stepId,
+                error: message,
+                timestamp: new Date().toISOString(),
+            });
+        }
+    });
+}
+//# sourceMappingURL=artifact-manager.js.map