ai-dev-requirements 0.1.9 → 0.1.10

package/README.md

@@ -2,7 +2,7 @@
 
 [中文](./README.zh-CN.md)
 
-A parallel-task development framework for AI coding tools, enabling end-to-end development workflow automation.
+An agent harness workflow for AI coding tools, enabling controlled requirement intake, planning, gated execution, verification, review, and handoff.
 
 ---
 
@@ -11,13 +11,13 @@ A parallel-task development framework for AI coding tools, enabling end-to-end d
 | Deliverable | Description |
 |-------------|-------------|
 | **Requirements MCP Server** (`src/`) | MCP server for fetching requirements, with built-in ONES adapter. Installable via npm. |
-| **Dev Workflow Skill** (`skills/dev-workflow/`) | Self-contained development workflow skill. Install it and run the full process. |
+| **Agent Harness Workflow Skill** (`skills/dev-workflow/`) | Self-contained agent harness skill. Install it to run requirement intake, planning, gated execution, verification, review, and handoff. |
 
 ---
 
 ## Quick Start
 
-### 1. Install Dev Workflow Skill
+### 1. Install Agent Harness Workflow Skill
 
 ```bash
 npx skills add daguanren21/ai-dev-workflow
@@ -29,9 +29,61 @@ Install to a specific agent with `-a`:
 npx skills add daguanren21/ai-dev-workflow -a claude-code
 ```
 
-Once installed, AI coding tools will automatically use the dev-workflow skill to drive the full development process.
+Once installed, AI coding tools will automatically use the dev-workflow harness to govern the full development process.
 
-### 2. Install MCP Server (Optional)
+### 2. Install For Codex
+
+Codex loads skills from `$CODEX_HOME/skills`. If `CODEX_HOME` is not set, the default is `~/.codex`.
+
+From this repository:
+
+```bash
+mkdir -p "${CODEX_HOME:-$HOME/.codex}/skills/dev-workflow"
+cp -R skills/dev-workflow/* "${CODEX_HOME:-$HOME/.codex}/skills/dev-workflow/"
+```
+
+For local development, use a symlink instead so Codex picks up edits from this checkout after restart:
+
+```bash
+mkdir -p "${CODEX_HOME:-$HOME/.codex}/skills"
+ln -s "$(pwd)/skills/dev-workflow" "${CODEX_HOME:-$HOME/.codex}/skills/dev-workflow"
+```
+
+Restart Codex after installing or updating the skill.
+
+### 3. Trigger The Harness
+
+The skill can be triggered automatically when the task looks like AI-assisted development work: requirement intake, issue implementation, task planning, gated execution, verification, review, or handoff.
+
+You can also trigger it explicitly:
+
+```text
+Use the dev-workflow harness to implement this requirement: <requirement text or ticket id>
+```
+
+```text
+Use the dev-workflow harness. Read ONES-123, write the plan first, then wait for confirmation before implementation.
+```
+
+```text
+Use the dev-workflow harness for this GitHub issue: <issue url>
+```
+
+When the harness is active, the agent should announce:
+
+```text
+I'm using the dev-workflow harness to drive this development task.
+```
+
+By default, the harness generates user stories and an implementation plan before writing code, then pauses for confirmation. You do not need to repeat "write the plan first" in every prompt. Say so only when you want to bypass that gate.
+
+Expected flow:
+
+```text
+Intake -> Context Load -> Normalize -> Harness Plan -> Coverage Validation -> Gated Execution -> Verification -> Review -> Handoff
+```
+
+### 4. Install MCP Server (Optional)
 
 If you use ONES for requirement management:
 
@@ -75,7 +127,7 @@ Add to your `.mcp.json`:
 }
 ```
 
-### 3. Add Companion MCP Servers (Optional)
+### 5. Add Companion MCP Servers (Optional)
 
 Requirements are not limited to ONES. Pair with official MCP servers for GitHub / Jira / Figma:
 
@@ -108,22 +160,24 @@ Requirements are not limited to ONES. Pair with official MCP servers for GitHub
 
 ---
 
-## Dev Workflow Skill
+## Agent Harness Workflow Skill
 
-A self-contained AI-assisted development workflow skill that drives 7 phases:
+A self-contained AI-assisted agent harness skill that governs the full development lifecycle:
 
 ```
-Requirements → User Stories → UI Resources → Skill Matching → Implementation Plan → Code → Verification
+Intake -> Context Load -> Normalize -> Harness Plan -> Coverage Validation -> Gated Execution -> Verification -> Review -> Handoff
 ```
 
+The harness follows a feedforward + feedback model: it guides the agent with plans, artifacts, and task boundaries, then uses deterministic gates such as lint, typecheck, build, tests, and review as backpressure before handoff.
+
 Skill directory structure:
 
 ```
 skills/dev-workflow/
-├── SKILL.md                         # Skill entry (YAML frontmatter + workflow definition)
+├── SKILL.md                         # Skill entry (YAML frontmatter + harness definition)
 └── references/
-    ├── workflow.md                  # 10-step end-to-end workflow
-    ├── task-types.md                # Task types, scheduling strategies, declaration syntax
+    ├── workflow.md                  # Agent harness lifecycle
+    ├── task-types.md                # Harness task types, scheduler modes, declaration syntax
     ├── service-transform.md         # Service-layer transform pattern for Mock/API adaptation
     └── templates/                   # Task declaration templates
         ├── code-dev-task.md
@@ -140,10 +194,10 @@ skills/dev-workflow/
 
 ```
 ai-dev-workflow/
-├── skills/dev-workflow/             # Dev Workflow Skill (self-contained)
+├── skills/dev-workflow/             # Agent Harness Workflow Skill (self-contained)
 │   ├── SKILL.md
 │   └── references/
-│       ├── workflow.md
+│       ├── workflow.md              # Agent harness lifecycle
 │       ├── task-types.md
 │       ├── service-transform.md
 │       └── templates/

package/README.zh-CN.md

@@ -2,7 +2,7 @@
 
 [English](./README.md)
 
-一套面向 AI 编码工具的并行任务开发框架，实现端到端的开发工作流自动化。
+一套面向 AI 编码工具的 agent harness 工作流，用于管控需求接入、计划、门禁执行、验证、审查和交付。
 
 ---
 
@@ -11,13 +11,13 @@
 | 交付物 | 说明 |
 |-------|------|
 | **Requirements MCP Server** (`src/`) | 需求获取 MCP 服务，内置 ONES 适配器，可通过 npm 安装 |
-| **Dev Workflow Skill** (`skills/dev-workflow/`) | 自包含的开发工作流 Skill，安装后即可跑通完整流程 |
+| **Agent Harness Workflow Skill** (`skills/dev-workflow/`) | 自包含的 AI agent harness 工作流 Skill，安装后即可跑通需求接入、计划、门禁执行、验证、审查和交付。 |
 
 ---
 
 ## 快速开始
 
-### 1. 安装 Dev Workflow Skill
+### 1. 安装 Agent Harness Workflow Skill
 
 ```bash
 npx skills add daguanren21/ai-dev-workflow
@@ -29,9 +29,61 @@ npx skills add daguanren21/ai-dev-workflow
 npx skills add daguanren21/ai-dev-workflow -a claude-code
 ```
 
-安装后，AI 编码工具会自动识别并使用 dev-workflow skill 驱动完整的开发流程。
+安装后，AI 编码工具会自动识别并使用 dev-workflow harness 管控完整开发流程。
 
-### 2. 安装 MCP Server（可选）
+### 2. 安装到 Codex
+
+Codex 从 `$CODEX_HOME/skills` 加载 skills。未设置 `CODEX_HOME` 时，默认目录是 `~/.codex`。
+
+从当前仓库安装：
+
+```bash
+mkdir -p "${CODEX_HOME:-$HOME/.codex}/skills/dev-workflow"
+cp -R skills/dev-workflow/* "${CODEX_HOME:-$HOME/.codex}/skills/dev-workflow/"
+```
+
+如果是在本地开发这个 skill，建议使用软链接，这样更新当前仓库后重启 Codex 即可生效：
+
+```bash
+mkdir -p "${CODEX_HOME:-$HOME/.codex}/skills"
+ln -s "$(pwd)/skills/dev-workflow" "${CODEX_HOME:-$HOME/.codex}/skills/dev-workflow"
+```
+
+安装或更新后需要重启 Codex。
+
+### 3. 触发 Harness
+
+当任务看起来是 AI 辅助开发工作时，skill 可以自动触发，例如：需求接入、issue 实现、任务规划、门禁执行、验证、审查或交付。
+
+也可以显式触发：
+
+```text
+使用 dev-workflow harness 实现这个需求：<需求文本或工单号>
+```
+
+```text
+使用 dev-workflow harness。读取 ONES-123，先写计划，确认后再实现。
+```
+
+```text
+使用 dev-workflow harness 处理这个 GitHub issue：<issue url>
+```
+
+Harness 生效时，agent 应该先声明：
+
+```text
+I'm using the dev-workflow harness to drive this development task.
+```
+
+默认情况下，harness 会先生成 user stories 和 implementation plan，然后暂停等待确认，再开始写代码。你不需要每次重复“先写计划再实现”。只有想跳过这个门禁时，才需要明确说明。
+
+预期流程：
+
+```text
+需求接入 → 上下文加载 → 需求规范化 → Harness 计划 → 覆盖校验 → 门禁执行 → 验证 → 审查 → 交付
+```
+
+### 4. 安装 MCP Server（可选）
 
 如果使用 ONES 进行需求管理：
 
@@ -75,7 +127,7 @@ npm install -g ai-dev-requirements
 }
 ```
 
-### 3. 搭配其他 MCP Server（可选）
+### 5. 搭配其他 MCP Server（可选）
 
 需求不限于 ONES，可搭配官方 MCP Server 获取 GitHub / Jira / Figma 资源：
 
@@ -108,22 +160,24 @@ npm install -g ai-dev-requirements
 
 ---
 
-## Dev Workflow Skill
+## Agent Harness Workflow Skill
 
-自包含的 AI 辅助开发工作流 Skill，安装后自动驱动 7 个阶段：
+自包含的 AI 辅助 agent harness 工作流 Skill，安装后自动管控完整开发生命周期：
 
 ```
-需求获取 → 用户故事 → UI 资源获取 → 技能匹配 → 实现计划 → 代码实现 → 验证
+需求接入 → 上下文加载 → 需求规范化 → Harness 计划 → 覆盖校验 → 门禁执行 → 验证 → 审查 → 交付
 ```
 
+这个 harness 遵循“前馈 + 反馈”模型：先用计划、产物和任务边界引导 agent，再用 lint、typecheck、build、tests、review 等确定性门禁形成反压，合格后再交付。
+
 Skill 目录结构：
 
 ```
 skills/dev-workflow/
-├── SKILL.md                         # Skill 入口（YAML frontmatter + 工作流定义）
+├── SKILL.md                         # Skill 入口（YAML frontmatter + harness 定义）
 └── references/
-    ├── workflow.md                  # 10 步端到端工作流
-    ├── task-types.md                # 任务类型、调度策略、声明语法
+    ├── workflow.md                  # Agent harness 生命周期
+    ├── task-types.md                # Harness 任务类型、调度模式、声明语法
     ├── service-transform.md         # Service 层 Transform 适配模式
     └── templates/                   # 任务声明模板
         ├── code-dev-task.md
@@ -140,10 +194,10 @@ skills/dev-workflow/
 
 ```
 ai-dev-workflow/
-├── skills/dev-workflow/             # Dev Workflow Skill（自包含工作流）
+├── skills/dev-workflow/             # Agent Harness Workflow Skill（自包含工作流）
 │   ├── SKILL.md
 │   └── references/
-│       ├── workflow.md
+│       ├── workflow.md              # Agent harness 生命周期
 │       ├── task-types.md
 │       ├── service-transform.md
 │       └── templates/

package/dist/index.cjs

@@ -93,6 +93,9 @@ const TASK_DETAIL_QUERY = `
   query Task($key: Key) {
     task(key: $key) {
       key uuid number name
+      description
+      descriptionText
+      desc_rich: description
       issueType { uuid name }
       status { uuid name category }
       priority { value }
@@ -322,7 +325,120 @@ function getSetCookies(response) {
 	const raw = response.headers.get("set-cookie");
 	return raw ? [raw] : [];
 }
-function toRequirement(task, description = "") {
+function extractWikiPageUuidsFromText(text) {
+	if (!text) return [];
+	const uuids = /* @__PURE__ */ new Set();
+	for (const pattern of [/\/page\/([\w-]+)/g, /page=([\w-]+)/g]) for (const match of text.matchAll(pattern)) if (match[1]) uuids.add(match[1]);
+	return [...uuids];
+}
+function htmlToPlainText(html) {
+	return html.replace(/<br\s*\/?>/gi, "\n").replace(/<\/p>/gi, "\n").replace(/<[^>]+>/g, "").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/\n{3,}/g, "\n\n").trim();
+}
+function getTaskDetailText(task) {
+	return task.descriptionText?.trim() || htmlToPlainText(task.desc_rich ?? task.description ?? "");
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseJsonRecord(value) {
+	try {
+		const parsed = JSON.parse(value);
+		return isRecord(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function asWikiBlocks(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter(isRecord);
+}
+function renderWikiTextRuns(value) {
+	if (!Array.isArray(value)) return "";
+	return value.map((run) => {
+		if (!isRecord(run)) return "";
+		const attributes = isRecord(run.attributes) ? run.attributes : {};
+		const insert = typeof run.insert === "string" ? run.insert.replace(/\u00A0/g, " ") : "";
+		const link = typeof attributes.link === "string" ? attributes.link : "";
+		if (link && insert.trim()) return `[${insert}](${link})`;
+		const taskName = typeof attributes.taskName === "string" ? attributes.taskName : "";
+		if (link && taskName) return `[${taskName}](${link})`;
+		return insert;
+	}).join("").replace(/\n{3,}/g, "\n\n").trim();
+}
+function renderWikiHeading(text, heading) {
+	if (!heading) return text;
+	const level = Math.min(Math.max(Math.trunc(heading), 1), 6);
+	return `${"#".repeat(level)} ${text}`;
+}
+function getWikiImageSource(block) {
+	const embedData = isRecord(block.embedData) ? block.embedData : {};
+	return typeof embedData.src === "string" ? embedData.src.trim() : "";
+}
+function renderWikiEmbed(block, context) {
+	if (block.embedType === "image") {
+		const src = getWikiImageSource(block);
+		if (src && !context.imageSources.includes(src)) context.imageSources.push(src);
+		return src ? `[Image: ${src}]` : "[Image]";
+	}
+	return block.embedType ? `[Embed: ${block.embedType}]` : "";
+}
+function escapeWikiTableCell(value) {
+	return value.replace(/\|/g, "\\|").replace(/[ \t]*\n+[ \t]*/g, " ").trim();
+}
+function renderWikiCell(value, document, context) {
+	const blocks = asWikiBlocks(value);
+	if (!blocks.length) return "";
+	return blocks.map((block) => renderWikiBlock(block, document, context)).filter(Boolean).join(" ").replace(/[ \t]*\n+[ \t]*/g, " ").trim();
+}
+function renderWikiTable(block, document, context) {
+	const cols = typeof block.cols === "number" && block.cols > 0 ? Math.trunc(block.cols) : 0;
+	const children = Array.isArray(block.children) ? block.children.filter((child) => typeof child === "string") : [];
+	if (!cols || !children.length) return "";
+	const rows = [];
+	for (let index = 0; index < children.length; index += cols) {
+		const cells = children.slice(index, index + cols).map((childId) => escapeWikiTableCell(renderWikiCell(document[childId], document, context)));
+		while (cells.length < cols) cells.push("");
+		rows.push(`| ${cells.join(" | ")} |`);
+	}
+	if (rows.length > 1) rows.splice(1, 0, `| ${Array.from({ length: cols }, () => "---").join(" | ")} |`);
+	return rows.join("\n");
+}
+function renderWikiBlock(block, document, context) {
+	if (block.type === "table") return renderWikiTable(block, document, context);
+	if (block.type === "embed") return renderWikiEmbed(block, context);
+	const text = renderWikiTextRuns(block.text);
+	if (!text) return "";
+	if (block.type === "list") {
+		const level = typeof block.level === "number" ? Math.max(Math.trunc(block.level), 1) : 1;
+		return `${"  ".repeat(level - 1)}${block.ordered ? `${block.start ?? 1}.` : "-"} ${text}`;
+	}
+	return renderWikiHeading(text, block.heading);
+}
+function renderWikiContent(content, context = { imageSources: [] }) {
+	const trimmed = content.trim();
+	if (!trimmed) return "";
+	const document = parseJsonRecord(trimmed);
+	if (!document) return trimmed;
+	if (!("blocks" in document)) return trimmed;
+	return asWikiBlocks(document.blocks).map((block) => renderWikiBlock(block, document, context)).filter(Boolean).join("\n\n").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function mimeTypeFromFileName(fileName) {
+	const normalized = fileName.toLowerCase();
+	if (normalized.endsWith(".jpg") || normalized.endsWith(".jpeg")) return "image/jpeg";
+	if (normalized.endsWith(".gif")) return "image/gif";
+	if (normalized.endsWith(".webp")) return "image/webp";
+	if (normalized.endsWith(".svg")) return "image/svg+xml";
+	return "image/png";
+}
+function attachmentNameFromPath(path) {
+	const name = path.split("/").pop() || path;
+	try {
+		return decodeURIComponent(name);
+	} catch {
+		return name;
+	}
+}
+function toRequirement(task, description = "", attachments = []) {
 	return {
 		id: task.uuid,
 		source: "ones",
@@ -337,7 +453,7 @@ function toRequirement(task, description = "") {
 		createdAt: "",
 		updatedAt: "",
 		dueDate: null,
-		attachments: [],
+		attachments,
 		raw: task
 	};
 }
@@ -617,12 +733,51 @@ var OnesAdapter = class extends BaseAdapter {
 	* Fetch wiki page content via REST API.
 	* Endpoint: /wiki/api/wiki/team/{teamUuid}/online_page/{wikiUuid}/content
 	*/
+	async fetchWikiPageDetail(wikiUuid) {
+		const session = await this.login();
+		const url = `${this.config.apiBase}/wiki/api/wiki/team/${session.teamUuid}/page/${wikiUuid}/detail`;
+		const response = await fetch(url, { headers: { Authorization: `Bearer ${session.accessToken}` } });
+		if (!response.ok) return {};
+		return response.json();
+	}
+	buildWikiImageUrl(session, refUuid, source, token) {
+		const encodedRefUuid = encodeURIComponent(refUuid);
+		const encodedSource = source.split("/").map((part) => encodeURIComponent(part)).join("/");
+		const encodedToken = encodeURIComponent(token);
+		return `${this.config.apiBase}/wiki/api/wiki/editor/${session.teamUuid}/${encodedRefUuid}/resources/${encodedSource}?token=${encodedToken}`;
+	}
 	async fetchWikiContent(wikiUuid) {
 		const session = await this.login();
 		const url = `${this.config.apiBase}/wiki/api/wiki/team/${session.teamUuid}/online_page/${wikiUuid}/content`;
 		const response = await fetch(url, { headers: { Authorization: `Bearer ${session.accessToken}` } });
-		if (!response.ok) return "";
-		return (await response.json()).content ?? "";
+		if (!response.ok) return {
+			content: "",
+			attachments: []
+		};
+		const data = await response.json();
+		const renderContext = { imageSources: [] };
+		const content = renderWikiContent(typeof data.content === "string" ? data.content : "", renderContext);
+		const token = typeof data.token === "string" ? data.token : "";
+		if (!renderContext.imageSources.length || !token) return {
+			content,
+			attachments: []
+		};
+		const detail = await this.fetchWikiPageDetail(wikiUuid);
+		const refUuid = typeof detail.ref_uuid === "string" ? detail.ref_uuid : "";
+		if (!refUuid) return {
+			content,
+			attachments: []
+		};
+		return {
+			content,
+			attachments: renderContext.imageSources.map((source, index) => ({
+				id: `${wikiUuid}-image-${index + 1}`,
+				name: attachmentNameFromPath(source),
+				url: this.buildWikiImageUrl(session, refUuid, source, token),
+				mimeType: mimeTypeFromFileName(source),
+				size: 0
+			}))
+		};
 	}
 	/**
 	* Fetch a single task by UUID or number (e.g. "#95945" or "95945").
@@ -650,13 +805,27 @@ var OnesAdapter = class extends BaseAdapter {
 		}
 		const task = (await this.graphql(TASK_DETAIL_QUERY, { key: `task-${taskUuid}` }, "Task")).data?.task;
 		if (!task) throw new Error(`ONES: Task "${taskUuid}" not found`);
-		const wikiPages = task.relatedWikiPages ?? [];
-		const wikiContents = await Promise.all(wikiPages.filter((w) => !w.errorMessage).map(async (wiki) => {
-			const content = await this.fetchWikiContent(wiki.uuid);
+		const wikiRefs = /* @__PURE__ */ new Map();
+		for (const wiki of task.relatedWikiPages ?? []) if (!wiki.errorMessage) wikiRefs.set(wiki.uuid, {
+			title: wiki.title,
+			uuid: wiki.uuid
+		});
+		const detailForLinkExtraction = [
+			task.description,
+			task.descriptionText,
+			task.desc_rich
+		].filter(Boolean).join("\n");
+		for (const wikiUuid of extractWikiPageUuidsFromText(detailForLinkExtraction)) if (!wikiRefs.has(wikiUuid)) wikiRefs.set(wikiUuid, {
+			title: `Wiki ${wikiUuid}`,
+			uuid: wikiUuid
+		});
+		const wikiContents = await Promise.all([...wikiRefs.values()].map(async (wiki) => {
+			const rendered = await this.fetchWikiContent(wiki.uuid);
 			return {
 				title: wiki.title,
 				uuid: wiki.uuid,
-				content
+				content: rendered.content,
+				attachments: rendered.attachments
 			};
 		}));
 		const parts = [];
@@ -695,7 +864,18 @@ var OnesAdapter = class extends BaseAdapter {
 				else parts.push("(No content available)");
 			}
 		}
-		return toRequirement(task, parts.join("\n"));
+		const detailText = getTaskDetailText(task);
+		const hasWikiContent = wikiContents.some((wiki) => wiki.content.trim());
+		if (detailText && !hasWikiContent) {
+			parts.push("");
+			parts.push("---");
+			parts.push("");
+			parts.push("## Requirement Detail");
+			parts.push("");
+			parts.push(detailText);
+		}
+		const wikiAttachments = wikiContents.flatMap((wiki) => wiki.attachments);
+		return toRequirement(task, parts.join("\n"), wikiAttachments);
 	}
 	/**
 	* Search tasks assigned to current user via GraphQL.
@@ -1116,7 +1296,7 @@ const GetIssueDetailSchema = zod_v4.z.object({
 * Download an image from URL and return as base64 data URI.
 * Returns null if download fails.
 */
-async function downloadImageAsBase64(url) {
+async function downloadImageAsBase64$1(url) {
 	try {
 		const res = await fetch(url, { redirect: "follow" });
 		if (!res.ok) return null;
@@ -1142,7 +1322,7 @@ async function handleGetIssueDetail(input, adapters, defaultSource) {
 	if (!adapter) throw new Error(`Source "${sourceType}" is not configured. Available: ${[...adapters.keys()].join(", ")}`);
 	const detail = await adapter.getIssueDetail({ issueId: input.issueId });
 	const imageUrls = detail.descriptionRich ? extractImageUrls(detail.descriptionRich) : [];
-	const imageResults = await Promise.all(imageUrls.map((url) => downloadImageAsBase64(url)));
+	const imageResults = await Promise.all(imageUrls.map((url) => downloadImageAsBase64$1(url)));
 	const content = [{
 		type: "text",
 		text: formatIssueDetail(detail)
@@ -1228,15 +1408,54 @@ const GetRequirementSchema = zod_v4.z.object({
 	id: zod_v4.z.string().describe("The requirement/issue ID"),
 	source: zod_v4.z.string().optional().describe("Source to fetch from. If omitted, uses the default source.")
 });
+async function downloadImageAsBase64(url, fallbackMimeType = "image/png") {
+	try {
+		const res = await fetch(url, { redirect: "follow" });
+		if (!res.ok) return null;
+		const mimeType = (res.headers.get("content-type") ?? fallbackMimeType).split(";")[0].trim() || fallbackMimeType;
+		return {
+			base64: Buffer.from(await res.arrayBuffer()).toString("base64"),
+			mimeType
+		};
+	} catch {
+		return null;
+	}
+}
+function isImageAttachment(attachment) {
+	if (attachment.mimeType.startsWith("image/")) return true;
+	return /\.(?:png|jpe?g|gif|webp|svg)$/i.test(attachment.url);
+}
+function displayAttachmentUrl(url) {
+	try {
+		const parsed = new URL(url);
+		parsed.search = "";
+		parsed.hash = "";
+		return parsed.toString();
+	} catch {
+		return url.replace(/[?#].*$/, "");
+	}
+}
 async function handleGetRequirement(input, adapters, defaultSource) {
 	const sourceType = input.source ?? defaultSource;
 	if (!sourceType) throw new Error("No source specified and no default source configured");
 	const adapter = adapters.get(sourceType);
 	if (!adapter) throw new Error(`Source "${sourceType}" is not configured. Available: ${[...adapters.keys()].join(", ")}`);
-	return { content: [{
+	const requirement = await adapter.getRequirement({ id: input.id });
+	const imageAttachments = requirement.attachments.filter(isImageAttachment);
+	const imageResults = await Promise.all(imageAttachments.map((attachment) => downloadImageAsBase64(attachment.url, attachment.mimeType)));
+	const content = [{
 		type: "text",
-		text: formatRequirement(await adapter.getRequirement({ id: input.id }))
-	}] };
+		text: formatRequirement(requirement)
+	}];
+	for (const image of imageResults) {
+		if (!image) continue;
+		content.push({
+			type: "image",
+			data: image.base64,
+			mimeType: image.mimeType
+		});
+	}
+	return { content };
 }
 function formatRequirement(req) {
 	const lines = [
@@ -1257,7 +1476,7 @@ function formatRequirement(req) {
 	lines.push("", "## Description", "", req.description || "_No description_");
 	if (req.attachments.length > 0) {
 		lines.push("", "## Attachments");
-		for (const att of req.attachments) lines.push(`- [${att.name}](${att.url}) (${att.mimeType}, ${att.size} bytes)`);
+		for (const att of req.attachments) lines.push(`- [${att.name}](${displayAttachmentUrl(att.url)}) (${att.mimeType}, ${att.size} bytes)`);
 	}
 	return lines.join("\n");
 }