agent-worker 0.3.0 → 0.4.0

package/dist/index.mjs

@@ -1,67 +1,69 @@
-import { a as CursorCliBackend, c as FRONTIER_MODELS, d as createModelAsync, i as SdkBackend, l as SUPPORTED_PROVIDERS, n as createBackend, o as CodexCliBackend, r as listBackends, s as ClaudeCliBackend, t as checkBackends, u as createModel } from "./backends-BZ866Ij9.mjs";
-import { a as createSkillsTool, c as createTools, i as parseImportSpec, n as buildGitUrl, o as SkillsProvider, r as getSpecDisplayName, s as AgentSession, t as SkillImporter } from "./skills-CVdxwuvV.mjs";
+import { _ as FRONTIER_MODELS, a as createMockBackend, b as createModelAsync, c as CodexBackend, i as MockAIBackend, l as ClaudeCodeBackend, n as createBackend, o as SdkBackend, r as listBackends, s as CursorBackend, t as checkBackends, v as SUPPORTED_PROVIDERS, y as createModel } from "./backends-DenGdkrj.mjs";
+import { a as createSkillsTool, c as createFeedbackTool, i as parseImportSpec, l as AgentSession, n as buildGitUrl, o as SkillsProvider, r as getSpecDisplayName, s as FEEDBACK_PROMPT, t as SkillImporter } from "./skills-VyC7eQyK.mjs";
+import { jsonSchema, tool } from "ai";
 import { createBashTool } from "bash-tool";
 
-//#region src/tools/bash.ts
+//#region src/agent/tools/bash.ts
 /**
 * Integration with Vercel's bash-tool for file system operations
 *
 * Provides bash, readFile, writeFile tools for AI agents in a sandboxed environment
 */
 /**
-* Create bash tools as ToolDefinition array for use with AgentSession
+* Create bash tools as AI SDK tool() objects for use with AgentSession
 *
 * @example
 * ```typescript
-* const bashTools = await createBashTools({
+* const { tools } = await createBashTools({
 *   files: { 'src/index.ts': 'console.log("hello")' }
 * })
 *
 * const session = new AgentSession({
 *   model: 'anthropic/claude-sonnet-4-5',
 *   system: 'You are a coding assistant.',
-*   tools: bashTools
+*   tools
 * })
 * ```
 */
 async function createBashTools(options = {}) {
 	const { includeReadFile = true, includeWriteFile = true, ...bashOptions } = options;
 	const toolkit = await createBashTool(bashOptions);
-	const tools = [];
-	tools.push({
-		name: "bash",
+	const tools = {};
+	tools.bash = tool({
 		description: "Execute bash commands in a sandboxed environment. Returns stdout, stderr, and exit code.",
-		parameters: {
+		inputSchema: jsonSchema({
 			type: "object",
 			properties: { command: {
 				type: "string",
 				description: "The bash command to execute"
 			} },
 			required: ["command"]
-		},
+		}),
 		execute: async (args) => {
-			return await toolkit.tools.bash.execute(args);
+			const bashTool = toolkit.tools.bash;
+			if (!bashTool?.execute) throw new Error("Bash tool not available");
+			return bashTool.execute(args, {});
 		}
 	});
-	if (includeReadFile) tools.push({
-		name: "readFile",
+	if (includeReadFile) tools.readFile = tool({
 		description: "Read the contents of a file from the sandbox filesystem.",
-		parameters: {
+		inputSchema: jsonSchema({
 			type: "object",
 			properties: { path: {
 				type: "string",
 				description: "The path to the file to read"
 			} },
 			required: ["path"]
-		},
+		}),
 		execute: async (args) => {
-			return await toolkit.tools.readFile.execute(args);
+			const readFileTool = toolkit.tools.readFile;
+			if (!readFileTool?.execute) throw new Error("ReadFile tool not available");
+			return readFileTool.execute(args, {});
 		}
 	});
-	if (includeWriteFile) tools.push({
-		name: "writeFile",
+	if (includeWriteFile) tools.writeFile = tool({
 		description: "Write content to a file in the sandbox filesystem. Creates parent directories if needed.",
-		parameters: {
+		inputSchema: jsonSchema({
 			type: "object",
 			properties: {
 				path: {
@@ -74,9 +76,11 @@ async function createBashTools(options = {}) {
 				}
 			},
 			required: ["path", "content"]
-		},
+		}),
 		execute: async (args) => {
-			return await toolkit.tools.writeFile.execute(args);
+			const writeFileTool = toolkit.tools.writeFile;
+			if (!writeFileTool?.execute) throw new Error("WriteFile tool not available");
+			return writeFileTool.execute(args, {});
 		}
 	});
 	return {
@@ -86,11 +90,6 @@ async function createBashTools(options = {}) {
 }
 /**
 * Quick helper to create bash tools with a directory
-*
-* @example
-* ```typescript
-* const { tools } = await createBashToolsFromDirectory('./src')
-* ```
 */
 async function createBashToolsFromDirectory(source, options = {}) {
 	return createBashTools({
@@ -100,14 +99,6 @@ async function createBashToolsFromDirectory(source, options = {}) {
 }
 /**
 * Quick helper to create bash tools with inline files
-*
-* @example
-* ```typescript
-* const { tools } = await createBashToolsFromFiles({
-*   'index.ts': 'console.log("hello")',
-*   'package.json': '{"name": "test"}'
-* })
-* ```
 */
 async function createBashToolsFromFiles(files, options = {}) {
 	return createBashTools({
@@ -117,4 +108,4 @@ async function createBashToolsFromFiles(files, options = {}) {
 }
 
 //#endregion
-export { AgentSession, ClaudeCliBackend, CodexCliBackend, CursorCliBackend, FRONTIER_MODELS, SUPPORTED_PROVIDERS, SdkBackend, SkillImporter, SkillsProvider, buildGitUrl, checkBackends, createBackend, createBashTool, createBashTools, createBashToolsFromDirectory, createBashToolsFromFiles, createModel, createModelAsync, createSkillsTool, createTools, getSpecDisplayName, listBackends, parseImportSpec };
+export { AgentSession, ClaudeCodeBackend, CodexBackend, CursorBackend, FEEDBACK_PROMPT, FRONTIER_MODELS, MockAIBackend, SUPPORTED_PROVIDERS, SdkBackend, SkillImporter, SkillsProvider, buildGitUrl, checkBackends, createBackend, createBashTool, createBashTools, createBashToolsFromDirectory, createBashToolsFromFiles, createFeedbackTool, createMockBackend, createModel, createModelAsync, createSkillsTool, getSpecDisplayName, listBackends, parseImportSpec };

package/dist/mcp-server-DtIApaBD.mjs

@@ -0,0 +1,549 @@
+import { o as MemoryStorage, s as ContextProviderImpl } from "./cli/index.mjs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+//#region src/workflow/context/memory-provider.ts
+/**
+* In-memory ContextProvider for testing.
+* All domain logic is inherited from ContextProviderImpl;
+* this class adds test helpers for inspection and cleanup.
+*/
+var MemoryContextProvider = class extends ContextProviderImpl {
+	memoryStorage;
+	constructor(validAgents) {
+		const storage = new MemoryStorage();
+		super(storage, validAgents);
+		this.memoryStorage = storage;
+	}
+	/** Get underlying MemoryStorage (for testing) */
+	getStorage() {
+		return this.memoryStorage;
+	}
+	/** Get all channel messages (for testing, unfiltered) */
+	async getMessages() {
+		return this.readChannel();
+	}
+	/** Clear all data (for testing) */
+	clear() {
+		this.memoryStorage.clear();
+	}
+	/** Get all resources (for testing) */
+	async getResources() {
+		const keys = await this.memoryStorage.list("resources/");
+		const map = /* @__PURE__ */ new Map();
+		for (const key of keys) {
+			const content = await this.memoryStorage.read(`resources/${key}`);
+			if (content !== null) {
+				const id = key.replace(/\.[^.]+$/, "");
+				map.set(id, content);
+			}
+		}
+		return map;
+	}
+	/** Get inbox state for an agent (for testing) */
+	async getInboxState(agent) {
+		const raw = await this.memoryStorage.read("_state/inbox.json");
+		if (!raw) return void 0;
+		try {
+			return JSON.parse(raw).readCursors?.[agent];
+		} catch {
+			return;
+		}
+	}
+	/** Get all documents (for testing) */
+	async getDocuments() {
+		const files = await this.memoryStorage.list("documents/");
+		const map = /* @__PURE__ */ new Map();
+		for (const file of files) {
+			const content = await this.memoryStorage.read(`documents/${file}`);
+			if (content !== null) map.set(file, content);
+		}
+		return map;
+	}
+};
+/**
+* Create a memory context provider
+*/
+function createMemoryContextProvider(validAgents) {
+	return new MemoryContextProvider(validAgents);
+}
+
+//#endregion
+//#region src/workflow/context/proposals.ts
+/**
+* Format a proposal for display
+*/
+function formatProposal(proposal) {
+	const lines = [];
+	lines.push(`📋 **${proposal.title}** (${proposal.id})`);
+	lines.push(`Type: ${proposal.type} | Status: ${proposal.status}`);
+	if (proposal.description) lines.push(`\n${proposal.description}`);
+	lines.push("\nOptions:");
+	for (const option of proposal.options) {
+		const count = proposal.result?.counts[option.id] || 0;
+		const marker = proposal.result?.winner === option.id ? "✓ " : "  ";
+		lines.push(`${marker}- ${option.label} (${option.id}): ${count} votes`);
+	}
+	if (proposal.result && Object.keys(proposal.result.votes).length > 0) {
+		lines.push("\nVotes:");
+		for (const [voter, choice] of Object.entries(proposal.result.votes)) lines.push(`  @${voter} → ${choice}`);
+	}
+	if (proposal.status === "active" && proposal.expiresAt) {
+		const remaining = new Date(proposal.expiresAt).getTime() - Date.now();
+		const minutes = Math.max(0, Math.floor(remaining / 6e4));
+		lines.push(`\nExpires in: ${minutes} minutes`);
+	}
+	if (proposal.status === "resolved" && proposal.result?.winner) {
+		const winningOption = proposal.options.find((o) => o.id === proposal.result?.winner);
+		lines.push(`\n🏆 Winner: ${winningOption?.label || proposal.result.winner}`);
+	}
+	return lines.join("\n");
+}
+/**
+* Format multiple proposals as a summary
+*/
+function formatProposalList(proposals) {
+	if (proposals.length === 0) return "(no proposals)";
+	return proposals.map((p) => {
+		const votes = Object.keys(p.result?.votes || {}).length;
+		return `- ${p.id}: ${p.title} [${p.status}] (${votes} votes)`;
+	}).join("\n");
+}
+
+//#endregion
+//#region src/workflow/context/mcp-server.ts
+/**
+* Context MCP Server
+* Provides context tools to agents via Model Context Protocol
+*
+* Tool Taxonomy:
+* - Channel:  channel_send, channel_read (public append-only log)
+* - Team:     team_members, team_doc_*, team_proposal_*, team_vote (shared workspace)
+* - My:       my_inbox, my_inbox_ack (personal agent tools)
+* - Resource: resource_create, resource_read (general-purpose reference mechanism)
+* - Feedback: feedback_submit (agent observations about tools/workflows, opt-in)
+*/
+/**
+* Format inbox messages for display
+*/
+function formatInbox(messages) {
+	if (messages.length === 0) return JSON.stringify({
+		messages: [],
+		count: 0
+	});
+	return JSON.stringify({
+		messages: messages.map((m) => ({
+			id: m.entry.id,
+			from: m.entry.from,
+			content: m.entry.content,
+			timestamp: m.entry.timestamp,
+			priority: m.priority
+		})),
+		count: messages.length
+	});
+}
+/**
+* Create an MCP server that exposes context tools
+*
+* Tool taxonomy:
+* - Channel:  channel_send, channel_read
+* - Team:     team_members, team_doc_read, team_doc_write, team_doc_append,
+*             team_doc_list, team_doc_create, team_proposal_create, team_vote,
+*             team_proposal_status, team_proposal_cancel
+* - My:       my_inbox, my_inbox_ack
+* - Resource: resource_create, resource_read
+*/
+function createContextMCPServer(options) {
+	const { provider, validAgents, name = "workflow-context", version = "1.0.0", onMention, proposalManager, feedback: feedbackEnabled, debugLog } = options;
+	const feedbackEntries = [];
+	const logTool = (tool, agent, params) => {
+		if (debugLog) debugLog(`[mcp:${agent || "anonymous"}] ${tool}(${Object.entries(params).filter(([_, v]) => v !== void 0).map(([k, v]) => {
+			const val = typeof v === "string" && v.length > 50 ? v.slice(0, 50) + "..." : v;
+			return `${k}=${JSON.stringify(val)}`;
+		}).join(", ")})`);
+	};
+	const server = new McpServer({
+		name,
+		version
+	});
+	const agentConnections = /* @__PURE__ */ new Map();
+	const CHANNEL_MSG_LIMIT = 2e3;
+	server.tool("channel_send", `Send a message to the shared channel. Use @agent to mention/notify. Use "to" for private DMs. Max ${CHANNEL_MSG_LIMIT} chars — for longer content, use resource_create first then reference the resource ID in your message.`, {
+		message: z.string().describe("Message content, can include @mentions like @reviewer or @coder"),
+		to: z.string().optional().describe("Send as DM to a specific agent (private, only you and recipient see it)")
+	}, async ({ message, to }, extra) => {
+		const from = getAgentId(extra) || "anonymous";
+		logTool("channel_send", from, {
+			message,
+			to
+		});
+		if (message.length > CHANNEL_MSG_LIMIT) return {
+			isError: true,
+			content: [{
+				type: "text",
+				text: `Message too long (${message.length} chars, max ${CHANNEL_MSG_LIMIT}). Use resource_create to store the full content, then send a short message referencing the resource ID.`
+			}]
+		};
+		const sendOpts = to ? { to } : void 0;
+		const msg = await provider.appendChannel(from, message, sendOpts);
+		for (const target of msg.mentions) if (onMention) onMention(from, target, msg);
+		if (to && !msg.mentions.includes(to) && onMention) onMention(from, to, msg);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				status: "sent",
+				timestamp: msg.timestamp,
+				mentions: msg.mentions,
+				to: msg.to
+			})
+		}] };
+	});
+	server.tool("channel_read", "Read messages from the shared channel. DMs and logs are automatically filtered based on your identity.", {
+		since: z.string().optional().describe("Read entries after this timestamp (ISO format)"),
+		limit: z.number().optional().describe("Maximum entries to return")
+	}, async ({ since, limit }, extra) => {
+		const agent = getAgentId(extra);
+		logTool("channel_read", agent, {
+			since,
+			limit
+		});
+		const entries = await provider.readChannel({
+			since,
+			limit,
+			agent
+		});
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(entries)
+		}] };
+	});
+	server.tool("resource_create", "Store large content as a resource. Returns a reference (resource:id) usable in channel messages or documents.", {
+		content: z.string().describe("Content to store as resource"),
+		type: z.enum([
+			"markdown",
+			"json",
+			"text",
+			"diff"
+		]).optional().describe("Content type hint (default: text)")
+	}, async ({ content, type }, extra) => {
+		const createdBy = getAgentId(extra) || "anonymous";
+		logTool("resource_create", createdBy, {
+			type,
+			contentLen: content.length
+		});
+		const result = await provider.createResource(content, createdBy, type);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				id: result.id,
+				ref: result.ref,
+				hint: `Use [description](${result.ref}) in messages or documents`
+			})
+		}] };
+	});
+	server.tool("resource_read", "Read resource content by ID. Use when you encounter resource:id references.", { id: z.string().describe("Resource ID (e.g., res_abc123)") }, async ({ id }) => {
+		const content = await provider.readResource(id);
+		if (content === null) return { content: [{
+			type: "text",
+			text: JSON.stringify({ error: `Resource not found: ${id}` })
+		}] };
+		return { content: [{
+			type: "text",
+			text: content
+		}] };
+	});
+	server.tool("my_inbox", "Check your unread inbox messages. Does NOT acknowledge — use my_inbox_ack after processing.", {}, async (_args, extra) => {
+		const agent = getAgentId(extra) || "anonymous";
+		logTool("my_inbox", agent, {});
+		const messages = await provider.getInbox(agent);
+		if (debugLog && messages.length > 0) debugLog(`[mcp:${agent}] my_inbox → ${messages.length} unread`);
+		return { content: [{
+			type: "text",
+			text: formatInbox(messages)
+		}] };
+	});
+	server.tool("my_inbox_ack", "Acknowledge inbox messages up to a message ID. Call after processing messages.", { until: z.string().describe("Acknowledge messages up to and including this message ID") }, async ({ until }, extra) => {
+		const agent = getAgentId(extra) || "anonymous";
+		logTool("my_inbox_ack", agent, { until });
+		await provider.ackInbox(agent, until);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				status: "acknowledged",
+				until
+			})
+		}] };
+	});
+	server.tool("team_members", "List all agents in this workflow. Use to discover who you can @mention.", {}, async (_args, extra) => {
+		const currentAgent = getAgentId(extra) || "anonymous";
+		const agents = validAgents.map((name) => ({
+			name,
+			mention: `@${name}`,
+			isYou: name === currentAgent
+		}));
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				agents,
+				count: agents.length,
+				hint: "Use @agent in channel_send to mention other agents"
+			})
+		}] };
+	});
+	server.tool("team_doc_read", "Read a shared team document.", { file: z.string().optional().describe("Document file path (default: notes.md)") }, async ({ file }, extra) => {
+		logTool("team_doc_read", getAgentId(extra), { file });
+		return { content: [{
+			type: "text",
+			text: await provider.readDocument(file) || "(empty document)"
+		}] };
+	});
+	server.tool("team_doc_write", "Write/replace a shared team document.", {
+		content: z.string().describe("New document content (replaces existing)"),
+		file: z.string().optional().describe("Document file path (default: notes.md)")
+	}, async ({ content, file }, extra) => {
+		logTool("team_doc_write", getAgentId(extra), {
+			file,
+			contentLen: content.length
+		});
+		await provider.writeDocument(content, file);
+		return { content: [{
+			type: "text",
+			text: `Document ${file || "notes.md"} written successfully`
+		}] };
+	});
+	server.tool("team_doc_append", "Append content to a shared team document.", {
+		content: z.string().describe("Content to append to the document"),
+		file: z.string().optional().describe("Document file path (default: notes.md)")
+	}, async ({ content, file }, extra) => {
+		logTool("team_doc_append", getAgentId(extra), {
+			file,
+			contentLen: content.length
+		});
+		await provider.appendDocument(content, file);
+		return { content: [{
+			type: "text",
+			text: `Content appended to ${file || "notes.md"}`
+		}] };
+	});
+	server.tool("team_doc_list", "List all shared team document files.", {}, async () => {
+		const files = await provider.listDocuments();
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				files,
+				count: files.length
+			})
+		}] };
+	});
+	server.tool("team_doc_create", "Create a new shared team document file.", {
+		file: z.string().describe("Document file path (e.g., \"findings/auth.md\")"),
+		content: z.string().describe("Initial document content")
+	}, async ({ file, content }) => {
+		await provider.createDocument(file, content);
+		return { content: [{
+			type: "text",
+			text: `Document ${file} created successfully`
+		}] };
+	});
+	if (proposalManager) {
+		server.tool("team_proposal_create", "Create a new proposal for team voting. Use for decisions, elections, approvals, or assignments.", {
+			type: z.enum([
+				"election",
+				"decision",
+				"approval",
+				"assignment"
+			]).describe("Type of proposal"),
+			title: z.string().describe("Brief title for the proposal"),
+			description: z.string().optional().describe("Detailed description"),
+			options: z.array(z.object({
+				id: z.string().describe("Unique option identifier"),
+				label: z.string().describe("Display label for the option")
+			})).optional().describe("Voting options (required except for approval type)"),
+			resolution: z.object({
+				type: z.enum([
+					"plurality",
+					"majority",
+					"unanimous"
+				]).optional().describe("How to determine winner"),
+				quorum: z.number().optional().describe("Minimum votes required"),
+				tieBreaker: z.enum([
+					"first",
+					"random",
+					"creator-decides"
+				]).optional().describe("How to break ties")
+			}).optional().describe("Resolution rules"),
+			binding: z.boolean().optional().describe("Whether result is binding (default: true)"),
+			timeoutSeconds: z.number().optional().describe("Timeout in seconds (default: 3600)")
+		}, async (params, extra) => {
+			const createdBy = getAgentId(extra) || "anonymous";
+			try {
+				const proposal = proposalManager.create({
+					type: params.type,
+					title: params.title,
+					description: params.description,
+					options: params.options,
+					resolution: params.resolution,
+					binding: params.binding,
+					timeoutSeconds: params.timeoutSeconds,
+					createdBy
+				});
+				const optionsList = proposal.options.map((o) => `${o.id}: ${o.label}`).join(", ");
+				const otherAgents = validAgents.filter((a) => a !== createdBy).map((a) => `@${a}`).join(" ");
+				await provider.appendChannel(createdBy, `Created proposal "${proposal.title}" (${proposal.id})\nOptions: ${optionsList}\nUse team_vote tool to cast your vote. ${otherAgents}`);
+				return { content: [{
+					type: "text",
+					text: JSON.stringify({
+						status: "created",
+						proposal: {
+							id: proposal.id,
+							title: proposal.title,
+							options: proposal.options,
+							expiresAt: proposal.expiresAt
+						}
+					})
+				}] };
+			} catch (error) {
+				return { content: [{
+					type: "text",
+					text: JSON.stringify({
+						status: "error",
+						error: error instanceof Error ? error.message : String(error)
+					})
+				}] };
+			}
+		});
+		server.tool("team_vote", "Cast your vote on a team proposal.", {
+			proposal: z.string().describe("Proposal ID (e.g., prop-1)"),
+			choice: z.string().describe("Option ID to vote for"),
+			reason: z.string().optional().describe("Optional reason for your vote")
+		}, async ({ proposal: proposalId, choice, reason }, extra) => {
+			const voter = getAgentId(extra) || "anonymous";
+			const result = proposalManager.vote({
+				proposalId,
+				voter,
+				choice,
+				reason
+			});
+			if (!result.success) return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					status: "error",
+					error: result.error
+				})
+			}] };
+			const reasonText = reason ? ` (reason: ${reason})` : "";
+			await provider.appendChannel(voter, `Voted "${choice}" on ${proposalId}${reasonText}`);
+			if (result.resolved && result.proposal) {
+				const winnerOption = result.proposal.options.find((o) => o.id === result.proposal.result?.winner);
+				const mentions = Object.keys(result.proposal.result?.votes || {}).map((v) => `@${v}`).join(" ");
+				await provider.appendChannel("system", `Proposal ${proposalId} resolved! Winner: ${winnerOption?.label || result.proposal.result?.winner || "none"} ${mentions}`);
+			}
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					status: "voted",
+					proposal: proposalId,
+					choice,
+					resolved: result.resolved,
+					winner: result.proposal?.result?.winner
+				})
+			}] };
+		});
+		server.tool("team_proposal_status", "Check status of team proposals. Omit proposal ID to see all active proposals.", { proposal: z.string().optional().describe("Proposal ID (omit for all active)") }, async ({ proposal: proposalId }) => {
+			if (proposalId) {
+				const proposal = proposalManager.get(proposalId);
+				if (!proposal) return { content: [{
+					type: "text",
+					text: JSON.stringify({
+						status: "error",
+						error: `Proposal not found: ${proposalId}`
+					})
+				}] };
+				return { content: [{
+					type: "text",
+					text: formatProposal(proposal)
+				}] };
+			}
+			const activeProposals = proposalManager.list("active");
+			return { content: [{
+				type: "text",
+				text: activeProposals.length > 0 ? formatProposalList(activeProposals) : "(no active proposals)"
+			}] };
+		});
+		server.tool("team_proposal_cancel", "Cancel a proposal you created.", { proposal: z.string().describe("Proposal ID to cancel") }, async ({ proposal: proposalId }, extra) => {
+			const cancelledBy = getAgentId(extra) || "anonymous";
+			const result = proposalManager.cancel(proposalId, cancelledBy);
+			if (!result.success) return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					status: "error",
+					error: result.error
+				})
+			}] };
+			await provider.appendChannel(cancelledBy, `Cancelled proposal ${proposalId}`);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					status: "cancelled",
+					proposal: proposalId
+				})
+			}] };
+		});
+	}
+	if (feedbackEnabled) server.tool("feedback_submit", "Report a workflow improvement need. Use when you hit something inconvenient — a missing tool, an awkward step, or a capability you wished you had.", {
+		target: z.string().describe("The area this is about — a tool name, a workflow step, or a general area (e.g. file search, code review)."),
+		type: z.enum([
+			"missing",
+			"friction",
+			"suggestion"
+		]).describe("missing: a tool or capability you needed but didn't have. friction: something that works but is awkward or slow. suggestion: a concrete improvement idea."),
+		description: z.string().describe("What you needed or what could be improved. Be specific."),
+		context: z.string().optional().describe("Optional: what you were trying to do when you hit this.")
+	}, async ({ target, type, description, context: ctx }, extra) => {
+		logTool("feedback_submit", getAgentId(extra) || "anonymous", {
+			target,
+			type
+		});
+		const entry = {
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			target,
+			type,
+			description,
+			...ctx ? { context: ctx } : {}
+		};
+		if (feedbackEntries.length >= 50) feedbackEntries.shift();
+		feedbackEntries.push(entry);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({ status: "recorded" })
+		}] };
+	});
+	return {
+		server,
+		agentConnections,
+		validAgents,
+		proposalManager,
+		getFeedback: () => [...feedbackEntries]
+	};
+}
+/**
+* Extract agent ID from MCP extra context
+* The agent ID is set via X-Agent-Id header or session metadata
+*/
+function getAgentId(extra) {
+	if (!extra || typeof extra !== "object") return void 0;
+	if ("sessionId" in extra && typeof extra.sessionId === "string") {
+		const sid = extra.sessionId;
+		const match = sid.match(/^(.+)-[0-9a-f]{8}$/);
+		return match ? match[1] : sid;
+	}
+	if ("meta" in extra && extra.meta && typeof extra.meta === "object") {
+		const meta = extra.meta;
+		if ("agentId" in meta && typeof meta.agentId === "string") return meta.agentId;
+	}
+}
+
+//#endregion
+export { createMemoryContextProvider as a, MemoryContextProvider as i, formatProposal as n, formatProposalList as r, createContextMCPServer as t };