@agent-workspace/mcp-server 0.2.1 → 0.4.0

package/dist/index.js

@@ -2,10 +2,61 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import * as z from "zod";
-import { readFile, writeFile, readdir, mkdir, access } from "node:fs/promises";
-import { join } from "node:path";
+import { readFile, writeFile, readdir, mkdir, access, stat } from "node:fs/promises";
+import { join, resolve, relative, isAbsolute } from "node:path";
 import matter from "gray-matter";
-import { AWP_VERSION, SMP_VERSION, MEMORY_DIR, ARTIFACTS_DIR } from "@agent-workspace/core";
+import { AWP_VERSION, SMP_VERSION, RDP_VERSION, CDP_VERSION, MEMORY_DIR, ARTIFACTS_DIR, REPUTATION_DIR, CONTRACTS_DIR, PROJECTS_DIR, } from "@agent-workspace/core";
+// =============================================================================
+// Security Constants
+// =============================================================================
+/** Maximum file size allowed (1MB) */
+const MAX_FILE_SIZE = 1024 * 1024;
+/** Pattern for valid slugs */
+const SLUG_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
+// =============================================================================
+// Security Utilities
+// =============================================================================
+/**
+ * Validate that a path is within the workspace root (prevents directory traversal).
+ * Returns the normalized absolute path if valid, or throws an error.
+ * @internal Available for future use in tool handlers
+ */
+export function _validatePath(root, targetPath) {
+    const normalized = resolve(root, targetPath);
+    const rel = relative(root, normalized);
+    // Prevent directory traversal
+    if (rel.startsWith("..") || isAbsolute(rel)) {
+        throw new Error(`Path traversal detected: ${targetPath}`);
+    }
+    return normalized;
+}
+/**
+ * Validate and sanitize a slug.
+ * Slugs must be lowercase alphanumeric with hyphens, not starting with hyphen.
+ * @internal Available for future use in tool handlers
+ */
+export function _validateSlug(slug) {
+    const trimmed = slug.trim().toLowerCase();
+    if (!SLUG_PATTERN.test(trimmed)) {
+        throw new Error(`Invalid slug: "${slug}". Must be lowercase alphanumeric with hyphens, not starting with hyphen.`);
+    }
+    // Additional safety: limit length
+    if (trimmed.length > 100) {
+        throw new Error(`Slug too long: max 100 characters`);
+    }
+    return trimmed;
+}
+/**
+ * Read a file with size limit check.
+ * @internal Available for future use in tool handlers
+ */
+export async function _safeReadFile(path) {
+    const stats = await stat(path);
+    if (stats.size > MAX_FILE_SIZE) {
+        throw new Error(`File too large: ${stats.size} bytes (max: ${MAX_FILE_SIZE})`);
+    }
+    return readFile(path, "utf-8");
+}
 const server = new McpServer({
     name: "awp-workspace",
     version: AWP_VERSION,
@@ -146,9 +197,7 @@ server.registerTool("awp_read_memory", {
         }
         catch {
             return {
-                content: [
-                    { type: "text", text: "No long-term memory file exists yet." },
-                ],
+                content: [{ type: "text", text: "No long-term memory file exists yet." }],
             };
         }
     }
@@ -171,9 +220,7 @@ server.registerTool("awp_read_memory", {
                 content: [
                     {
                         type: "text",
-                        text: results.length
-                            ? results.join("\n\n")
-                            : "No recent memory entries.",
+                        text: results.length ? results.join("\n\n") : "No recent memory entries.",
                     },
                 ],
             };
@@ -200,9 +247,7 @@ server.registerTool("awp_read_memory", {
     }
     catch {
         return {
-            content: [
-                { type: "text", text: `No memory entry for ${target}.` },
-            ],
+            content: [{ type: "text", text: `No memory entry for ${target}.` }],
         };
     }
 });
@@ -212,10 +257,7 @@ server.registerTool("awp_write_memory", {
     description: "Append an entry to today's memory log in the AWP workspace",
     inputSchema: {
         content: z.string().describe("The memory entry to log"),
-        tags: z
-            .array(z.string())
-            .optional()
-            .describe("Optional categorization tags"),
+        tags: z.array(z.string()).optional().describe("Optional categorization tags"),
     },
 }, async ({ content: entryContent, tags }) => {
     const root = getWorkspaceRoot();
@@ -285,9 +327,7 @@ server.registerTool("awp_artifact_read", {
     }
     catch {
         return {
-            content: [
-                { type: "text", text: `Artifact "${slug}" not found.` },
-            ],
+            content: [{ type: "text", text: `Artifact "${slug}" not found.` }],
             isError: true,
         };
     }
@@ -301,12 +341,7 @@ server.registerTool("awp_artifact_write", {
         title: z.string().optional().describe("Title (required for new artifacts)"),
         content: z.string().describe("Markdown body content"),
         tags: z.array(z.string()).optional().describe("Categorization tags"),
-        confidence: z
-            .number()
-            .min(0)
-            .max(1)
-            .optional()
-            .describe("Confidence score (0.0-1.0)"),
+        confidence: z.number().min(0).max(1).optional().describe("Confidence score (0.0-1.0)"),
         message: z.string().optional().describe("Commit message for provenance"),
     },
 }, async ({ slug, title, content: bodyContent, tags, confidence, message }) => {
@@ -413,9 +448,7 @@ server.registerTool("awp_artifact_list", {
     }
     catch {
         return {
-            content: [
-                { type: "text", text: JSON.stringify({ artifacts: [] }, null, 2) },
-            ],
+            content: [{ type: "text", text: JSON.stringify({ artifacts: [] }, null, 2) }],
         };
     }
     const mdFiles = files.filter((f) => f.endsWith(".md")).sort();
@@ -469,9 +502,7 @@ server.registerTool("awp_artifact_search", {
     }
     catch {
         return {
-            content: [
-                { type: "text", text: JSON.stringify({ results: [] }, null, 2) },
-            ],
+            content: [{ type: "text", text: JSON.stringify({ results: [] }, null, 2) }],
         };
     }
     const mdFiles = files.filter((f) => f.endsWith(".md")).sort();
@@ -492,11 +523,7 @@ server.registerTool("awp_artifact_search", {
                     version: data.version,
                     confidence: data.confidence,
                     tags: data.tags,
-                    matchedIn: [
-                        titleMatch && "title",
-                        tagMatch && "tags",
-                        bodyMatch && "body",
-                    ].filter(Boolean),
+                    matchedIn: [titleMatch && "title", tagMatch && "tags", bodyMatch && "body"].filter(Boolean),
                 });
             }
         }
@@ -516,7 +543,7 @@ server.registerTool("awp_artifact_search", {
 // --- Tool: awp_workspace_status ---
 server.registerTool("awp_workspace_status", {
     title: "Workspace Status",
-    description: "Get AWP workspace health status — manifest info, file presence, memory stats, artifact count",
+    description: "Get AWP workspace health status — manifest, files, projects, tasks, reputation, contracts, artifacts, memory, health warnings",
     inputSchema: {},
 }, async () => {
     const root = getWorkspaceRoot();
@@ -567,9 +594,1250 @@ server.registerTool("awp_workspace_status", {
     catch {
         status.artifacts = { count: 0 };
     }
+    // Reputation stats
+    try {
+        const repDir = join(root, REPUTATION_DIR);
+        const files = await readdir(repDir);
+        const mdFiles = files.filter((f) => f.endsWith(".md"));
+        status.reputation = { count: mdFiles.length };
+    }
+    catch {
+        status.reputation = { count: 0 };
+    }
+    // Contract stats
+    try {
+        const conDir = join(root, CONTRACTS_DIR);
+        const files = await readdir(conDir);
+        const mdFiles = files.filter((f) => f.endsWith(".md"));
+        status.contracts = { count: mdFiles.length };
+    }
+    catch {
+        status.contracts = { count: 0 };
+    }
+    // Project + task stats
+    const projectsSummary = [];
+    let totalTasks = 0;
+    let activeTasks = 0;
+    try {
+        const projDir = join(root, PROJECTS_DIR);
+        const projFiles = await readdir(projDir);
+        const mdFiles = projFiles.filter((f) => f.endsWith(".md")).sort();
+        for (const f of mdFiles) {
+            try {
+                const raw = await readFile(join(projDir, f), "utf-8");
+                const { data } = matter(raw);
+                if (data.type !== "project")
+                    continue;
+                const slug = f.replace(/\.md$/, "");
+                const projInfo = {
+                    slug,
+                    title: data.title,
+                    status: data.status,
+                    taskCount: data.taskCount || 0,
+                    completedCount: data.completedCount || 0,
+                };
+                if (data.deadline)
+                    projInfo.deadline = data.deadline;
+                projectsSummary.push(projInfo);
+                totalTasks += data.taskCount || 0;
+                // Count active tasks
+                try {
+                    const taskDir = join(projDir, slug, "tasks");
+                    const taskFiles = await readdir(taskDir);
+                    for (const tf of taskFiles.filter((t) => t.endsWith(".md"))) {
+                        try {
+                            const tRaw = await readFile(join(taskDir, tf), "utf-8");
+                            const { data: tData } = matter(tRaw);
+                            if (tData.status === "in-progress" ||
+                                tData.status === "blocked" ||
+                                tData.status === "review") {
+                                activeTasks++;
+                            }
+                        }
+                        catch {
+                            /* skip */
+                        }
+                    }
+                }
+                catch {
+                    /* no tasks dir */
+                }
+            }
+            catch {
+                /* skip */
+            }
+        }
+    }
+    catch {
+        /* no projects dir */
+    }
+    status.projects = {
+        count: projectsSummary.length,
+        totalTasks,
+        activeTasks,
+        list: projectsSummary,
+    };
+    // Health warnings
+    const warnings = [];
+    const now = new Date();
+    const MS_PER_DAY = 24 * 60 * 60 * 1000;
+    // Check required files
+    if (!status.files["IDENTITY.md"])
+        warnings.push("IDENTITY.md missing");
+    if (!status.files["SOUL.md"])
+        warnings.push("SOUL.md missing");
+    // Check contract deadlines
+    try {
+        const conDir = join(root, CONTRACTS_DIR);
+        const conFiles = await readdir(conDir);
+        for (const f of conFiles.filter((f) => f.endsWith(".md"))) {
+            try {
+                const raw = await readFile(join(conDir, f), "utf-8");
+                const { data } = matter(raw);
+                if (data.deadline && (data.status === "active" || data.status === "draft")) {
+                    if (new Date(data.deadline) < now) {
+                        warnings.push(`Contract "${f.replace(/\.md$/, "")}" is past deadline`);
+                    }
+                }
+            }
+            catch {
+                /* skip */
+            }
+        }
+    }
+    catch {
+        /* no contracts */
+    }
+    // Check reputation decay
+    try {
+        const repDir = join(root, REPUTATION_DIR);
+        const repFiles = await readdir(repDir);
+        for (const f of repFiles.filter((f) => f.endsWith(".md"))) {
+            try {
+                const raw = await readFile(join(repDir, f), "utf-8");
+                const { data } = matter(raw);
+                if (data.lastUpdated) {
+                    const daysSince = Math.floor((now.getTime() - new Date(data.lastUpdated).getTime()) / MS_PER_DAY);
+                    if (daysSince > 30) {
+                        warnings.push(`${f.replace(/\.md$/, "")} reputation decaying (no signal in ${daysSince} days)`);
+                    }
+                }
+            }
+            catch {
+                /* skip */
+            }
+        }
+    }
+    catch {
+        /* no reputation */
+    }
+    status.health = {
+        warnings,
+        ok: warnings.length === 0,
+    };
+    return {
+        content: [{ type: "text", text: JSON.stringify(status, null, 2) }],
+    };
+});
+// --- Tool: awp_reputation_query ---
+server.registerTool("awp_reputation_query", {
+    title: "Query Reputation",
+    description: "Query an agent's reputation profile. Returns multi-dimensional scores with decay applied. Omit slug to list all tracked agents.",
+    inputSchema: {
+        slug: z.string().optional().describe("Agent reputation slug (omit to list all)"),
+        dimension: z.string().optional().describe("Filter by dimension"),
+        domain: z.string().optional().describe("Filter by domain competence"),
+    },
+}, async ({ slug, dimension, domain }) => {
+    const root = getWorkspaceRoot();
+    if (!slug) {
+        // List all profiles
+        const repDir = join(root, REPUTATION_DIR);
+        let files;
+        try {
+            files = await readdir(repDir);
+        }
+        catch {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ profiles: [] }, null, 2) }],
+            };
+        }
+        const profiles = [];
+        for (const f of files.filter((f) => f.endsWith(".md")).sort()) {
+            try {
+                const raw = await readFile(join(repDir, f), "utf-8");
+                const { data } = matter(raw);
+                if (data.type !== "reputation-profile")
+                    continue;
+                profiles.push({
+                    slug: f.replace(/\.md$/, ""),
+                    agentName: data.agentName,
+                    agentDid: data.agentDid,
+                    signalCount: data.signals?.length || 0,
+                    dimensions: Object.keys(data.dimensions || {}),
+                    domains: Object.keys(data.domainCompetence || {}),
+                });
+            }
+            catch {
+                /* skip */
+            }
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify({ profiles }, null, 2) }],
+        };
+    }
+    // Read specific profile
+    const path = join(root, REPUTATION_DIR, `${slug}.md`);
+    try {
+        const raw = await readFile(path, "utf-8");
+        const { data, content } = matter(raw);
+        // Apply decay to scores
+        const now = new Date();
+        const DECAY_RATE = 0.02;
+        const MS_PER_MONTH = 30.44 * 24 * 60 * 60 * 1000;
+        const applyDecay = (dim) => {
+            if (!dim?.lastSignal)
+                return dim;
+            const months = (now.getTime() - new Date(dim.lastSignal).getTime()) / MS_PER_MONTH;
+            if (months <= 0)
+                return { ...dim };
+            const factor = Math.exp(-DECAY_RATE * months);
+            const decayed = 0.5 + (dim.score - 0.5) * factor;
+            return { ...dim, decayedScore: Math.round(decayed * 1000) / 1000 };
+        };
+        const result = { ...data, body: content.trim() };
+        // Apply decay to dimensions
+        if (data.dimensions) {
+            result.dimensions = {};
+            for (const [name, dim] of Object.entries(data.dimensions)) {
+                if (dimension && name !== dimension)
+                    continue;
+                result.dimensions[name] = applyDecay(dim);
+            }
+        }
+        if (data.domainCompetence) {
+            result.domainCompetence = {};
+            for (const [name, dim] of Object.entries(data.domainCompetence)) {
+                if (domain && name !== domain)
+                    continue;
+                result.domainCompetence[name] = applyDecay(dim);
+            }
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    catch {
+        return {
+            content: [{ type: "text", text: `Reputation profile "${slug}" not found.` }],
+            isError: true,
+        };
+    }
+});
+// --- Tool: awp_reputation_signal ---
+server.registerTool("awp_reputation_signal", {
+    title: "Log Reputation Signal",
+    description: "Log a reputation signal for an agent. Creates the profile if it doesn't exist (requires agentDid and agentName for new profiles).",
+    inputSchema: {
+        slug: z.string().describe("Agent reputation slug"),
+        dimension: z
+            .string()
+            .describe("Dimension (reliability, epistemic-hygiene, coordination, domain-competence)"),
+        score: z.number().min(0).max(1).describe("Score (0.0-1.0)"),
+        domain: z.string().optional().describe("Domain (required for domain-competence)"),
+        evidence: z.string().optional().describe("Evidence reference"),
+        message: z.string().optional().describe("Human-readable note"),
+        agentDid: z.string().optional().describe("Agent DID (required for new profiles)"),
+        agentName: z.string().optional().describe("Agent name (required for new profiles)"),
+    },
+}, async ({ slug, dimension: dim, score, domain, evidence, message, agentDid: newDid, agentName: newName, }) => {
+    const root = getWorkspaceRoot();
+    const repDir = join(root, REPUTATION_DIR);
+    await mkdir(repDir, { recursive: true });
+    const filePath = join(repDir, `${slug}.md`);
+    const sourceDid = await getAgentDid(root);
+    const now = new Date();
+    const timestamp = now.toISOString();
+    const ALPHA = 0.15;
+    const signal = { source: sourceDid, dimension: dim, score, timestamp };
+    if (domain)
+        signal.domain = domain;
+    if (evidence)
+        signal.evidence = evidence;
+    if (message)
+        signal.message = message;
+    const updateDim = (existing, signalScore) => {
+        if (!existing) {
+            return {
+                score: signalScore,
+                confidence: Math.round((1 - 1 / (1 + 1 * 0.1)) * 100) / 100,
+                sampleSize: 1,
+                lastSignal: timestamp,
+            };
+        }
+        // Apply decay then EWMA
+        const MS_PER_MONTH = 30.44 * 24 * 60 * 60 * 1000;
+        const months = (now.getTime() - new Date(existing.lastSignal).getTime()) / MS_PER_MONTH;
+        const decayFactor = months > 0 ? Math.exp(-0.02 * months) : 1;
+        const decayed = 0.5 + (existing.score - 0.5) * decayFactor;
+        const newScore = ALPHA * signalScore + (1 - ALPHA) * decayed;
+        const newSampleSize = existing.sampleSize + 1;
+        return {
+            score: Math.round(newScore * 1000) / 1000,
+            confidence: Math.round((1 - 1 / (1 + newSampleSize * 0.1)) * 100) / 100,
+            sampleSize: newSampleSize,
+            lastSignal: timestamp,
+        };
+    };
+    let isNew = false;
+    let fileData;
+    try {
+        const raw = await readFile(filePath, "utf-8");
+        fileData = matter(raw);
+    }
+    catch {
+        // New profile
+        if (!newDid || !newName) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: agentDid and agentName required for new profiles.",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        isNew = true;
+        fileData = {
+            data: {
+                awp: AWP_VERSION,
+                rdp: RDP_VERSION,
+                type: "reputation-profile",
+                id: `reputation:${slug}`,
+                agentDid: newDid,
+                agentName: newName,
+                lastUpdated: timestamp,
+                dimensions: {},
+                domainCompetence: {},
+                signals: [],
+            },
+            content: `\n# ${newName} — Reputation Profile\n\nTracked since ${timestamp.split("T")[0]}.\n`,
+        };
+    }
+    fileData.data.lastUpdated = timestamp;
+    fileData.data.signals.push(signal);
+    if (!fileData.data.dimensions)
+        fileData.data.dimensions = {};
+    if (!fileData.data.domainCompetence)
+        fileData.data.domainCompetence = {};
+    if (dim === "domain-competence" && domain) {
+        fileData.data.domainCompetence[domain] = updateDim(fileData.data.domainCompetence[domain], score);
+    }
+    else {
+        fileData.data.dimensions[dim] = updateDim(fileData.data.dimensions[dim], score);
+    }
+    const output = matter.stringify(fileData.content, fileData.data);
+    await writeFile(filePath, output, "utf-8");
+    return {
+        content: [
+            {
+                type: "text",
+                text: `${isNew ? "Created" : "Updated"} reputation/${slug}.md — ${dim}${domain ? `:${domain}` : ""}: ${score}`,
+            },
+        ],
+    };
+});
+// --- Tool: awp_contract_create ---
+server.registerTool("awp_contract_create", {
+    title: "Create Delegation Contract",
+    description: "Create a new delegation contract between agents with task definition and evaluation criteria.",
+    inputSchema: {
+        slug: z.string().describe("Contract slug"),
+        delegate: z.string().describe("Delegate agent DID"),
+        delegateSlug: z.string().describe("Delegate reputation profile slug"),
+        description: z.string().describe("Task description"),
+        deadline: z.string().optional().describe("Deadline (ISO 8601)"),
+        outputFormat: z.string().optional().describe("Expected output type"),
+        outputSlug: z.string().optional().describe("Expected output artifact slug"),
+        criteria: z
+            .record(z.string(), z.number())
+            .optional()
+            .describe("Evaluation criteria weights (default: completeness:0.3, accuracy:0.4, clarity:0.2, timeliness:0.1)"),
+    },
+}, async ({ slug, delegate, delegateSlug, description, deadline, outputFormat, outputSlug, criteria, }) => {
+    const root = getWorkspaceRoot();
+    const conDir = join(root, CONTRACTS_DIR);
+    await mkdir(conDir, { recursive: true });
+    const filePath = join(conDir, `${slug}.md`);
+    const delegatorDid = await getAgentDid(root);
+    const now = new Date().toISOString();
+    const evalCriteria = criteria || {
+        completeness: 0.3,
+        accuracy: 0.4,
+        clarity: 0.2,
+        timeliness: 0.1,
+    };
+    const data = {
+        awp: AWP_VERSION,
+        rdp: RDP_VERSION,
+        type: "delegation-contract",
+        id: `contract:${slug}`,
+        status: "active",
+        delegator: delegatorDid,
+        delegate,
+        delegateSlug,
+        created: now,
+        task: { description },
+        evaluation: { criteria: evalCriteria, result: null },
+    };
+    if (deadline)
+        data.deadline = deadline;
+    if (outputFormat)
+        data.task.outputFormat = outputFormat;
+    if (outputSlug)
+        data.task.outputSlug = outputSlug;
+    const body = `\n# ${slug} — Delegation Contract\n\nDelegated to ${delegateSlug}: ${description}\n\n## Status\nActive — awaiting completion.\n`;
+    const output = matter.stringify(body, data);
+    await writeFile(filePath, output, "utf-8");
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Created contracts/${slug}.md (status: active)`,
+            },
+        ],
+    };
+});
+// --- Tool: awp_contract_evaluate ---
+server.registerTool("awp_contract_evaluate", {
+    title: "Evaluate Delegation Contract",
+    description: "Evaluate a completed contract with scores for each criterion. Generates reputation signals for the delegate automatically.",
+    inputSchema: {
+        slug: z.string().describe("Contract slug"),
+        scores: z
+            .record(z.string(), z.number().min(0).max(1))
+            .describe("Map of criterion name to score (0.0-1.0)"),
+    },
+}, async ({ slug, scores }) => {
+    const root = getWorkspaceRoot();
+    const filePath = join(root, CONTRACTS_DIR, `${slug}.md`);
+    let fileData;
+    try {
+        const raw = await readFile(filePath, "utf-8");
+        fileData = matter(raw);
+    }
+    catch {
+        return {
+            content: [{ type: "text", text: `Contract "${slug}" not found.` }],
+            isError: true,
+        };
+    }
+    if (fileData.data.status === "evaluated") {
+        return {
+            content: [{ type: "text", text: "Contract has already been evaluated." }],
+            isError: true,
+        };
+    }
+    const criteria = fileData.data.evaluation.criteria;
+    const scoreMap = scores;
+    let weightedScore = 0;
+    for (const [name, weight] of Object.entries(criteria)) {
+        if (scoreMap[name] === undefined) {
+            return {
+                content: [{ type: "text", text: `Missing score for criterion: ${name}` }],
+                isError: true,
+            };
+        }
+        weightedScore += weight * scoreMap[name];
+    }
+    weightedScore = Math.round(weightedScore * 1000) / 1000;
+    // Update contract
+    fileData.data.status = "evaluated";
+    fileData.data.evaluation.result = scores;
+    const contractOutput = matter.stringify(fileData.content, fileData.data);
+    await writeFile(filePath, contractOutput, "utf-8");
+    // Generate reputation signal for delegate
+    const evaluatorDid = await getAgentDid(root);
+    const delegateSlug = fileData.data.delegateSlug;
+    const now = new Date();
+    const timestamp = now.toISOString();
+    const signal = {
+        source: evaluatorDid,
+        dimension: "reliability",
+        score: weightedScore,
+        timestamp,
+        evidence: fileData.data.id,
+        message: `Contract evaluation: ${fileData.data.task.description}`,
+    };
+    // Try to update delegate's reputation profile
+    const repPath = join(root, REPUTATION_DIR, `${delegateSlug}.md`);
+    let repUpdated = false;
+    try {
+        const repRaw = await readFile(repPath, "utf-8");
+        const repData = matter(repRaw);
+        repData.data.lastUpdated = timestamp;
+        repData.data.signals.push(signal);
+        if (!repData.data.dimensions)
+            repData.data.dimensions = {};
+        const existing = repData.data.dimensions.reliability;
+        const ALPHA = 0.15;
+        const MS_PER_MONTH = 30.44 * 24 * 60 * 60 * 1000;
+        if (existing) {
+            const months = (now.getTime() - new Date(existing.lastSignal).getTime()) / MS_PER_MONTH;
+            const decayFactor = months > 0 ? Math.exp(-0.02 * months) : 1;
+            const decayed = 0.5 + (existing.score - 0.5) * decayFactor;
+            const newScore = ALPHA * weightedScore + (1 - ALPHA) * decayed;
+            const newSampleSize = existing.sampleSize + 1;
+            repData.data.dimensions.reliability = {
+                score: Math.round(newScore * 1000) / 1000,
+                confidence: Math.round((1 - 1 / (1 + newSampleSize * 0.1)) * 100) / 100,
+                sampleSize: newSampleSize,
+                lastSignal: timestamp,
+            };
+        }
+        else {
+            repData.data.dimensions.reliability = {
+                score: weightedScore,
+                confidence: Math.round((1 - 1 / (1 + 1 * 0.1)) * 100) / 100,
+                sampleSize: 1,
+                lastSignal: timestamp,
+            };
+        }
+        const repOutput = matter.stringify(repData.content, repData.data);
+        await writeFile(repPath, repOutput, "utf-8");
+        repUpdated = true;
+    }
+    catch {
+        // No profile — that's OK
+    }
+    const resultText = [
+        `Evaluated contracts/${slug}.md — weighted score: ${weightedScore}`,
+        repUpdated
+            ? `Updated reputation/${delegateSlug}.md with reliability signal`
+            : `Note: No reputation profile for ${delegateSlug} — signal not recorded`,
+    ].join("\n");
+    return {
+        content: [{ type: "text", text: resultText }],
+    };
+});
+// --- Tool: awp_project_create ---
+server.registerTool("awp_project_create", {
+    title: "Create Project",
+    description: "Create a new coordination project with member roles and optional reputation gates.",
+    inputSchema: {
+        slug: z.string().describe("Project slug (e.g., 'q3-product-launch')"),
+        title: z.string().optional().describe("Project title"),
+        deadline: z.string().optional().describe("Deadline (ISO 8601 or YYYY-MM-DD)"),
+        tags: z.array(z.string()).optional().describe("Classification tags"),
+    },
+}, async ({ slug, title, deadline, tags }) => {
+    const root = getWorkspaceRoot();
+    const projDir = join(root, PROJECTS_DIR);
+    await mkdir(projDir, { recursive: true });
+    const filePath = join(projDir, `${slug}.md`);
+    if (await fileExists(filePath)) {
+        return {
+            content: [{ type: "text", text: `Project "${slug}" already exists.` }],
+            isError: true,
+        };
+    }
+    const did = await getAgentDid(root);
+    const now = new Date().toISOString();
+    const projectTitle = title ||
+        slug
+            .split("-")
+            .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+            .join(" ");
+    const data = {
+        awp: AWP_VERSION,
+        cdp: CDP_VERSION,
+        type: "project",
+        id: `project:${slug}`,
+        title: projectTitle,
+        status: "active",
+        owner: did,
+        created: now,
+        members: [{ did, role: "lead", slug: "self" }],
+        taskCount: 0,
+        completedCount: 0,
+    };
+    if (deadline)
+        data.deadline = deadline;
+    if (tags?.length)
+        data.tags = tags;
+    const body = `\n# ${projectTitle}\n\n`;
+    const output = matter.stringify(body, data);
+    await writeFile(filePath, output, "utf-8");
+    return {
+        content: [{ type: "text", text: `Created projects/${slug}.md (status: active)` }],
+    };
+});
+// --- Tool: awp_project_list ---
+server.registerTool("awp_project_list", {
+    title: "List Projects",
+    description: "List all projects in the workspace with status and task progress.",
+    inputSchema: {
+        status: z
+            .string()
+            .optional()
+            .describe("Filter by status (draft, active, paused, completed, archived)"),
+    },
+}, async ({ status: statusFilter }) => {
+    const root = getWorkspaceRoot();
+    const projDir = join(root, PROJECTS_DIR);
+    let files;
+    try {
+        files = await readdir(projDir);
+    }
+    catch {
+        return {
+            content: [{ type: "text", text: JSON.stringify({ projects: [] }, null, 2) }],
+        };
+    }
+    const projects = [];
+    for (const f of files.filter((f) => f.endsWith(".md")).sort()) {
+        try {
+            const raw = await readFile(join(projDir, f), "utf-8");
+            const { data } = matter(raw);
+            if (data.type !== "project")
+                continue;
+            if (statusFilter && data.status !== statusFilter)
+                continue;
+            projects.push({
+                slug: f.replace(/\.md$/, ""),
+                title: data.title,
+                status: data.status,
+                taskCount: data.taskCount || 0,
+                completedCount: data.completedCount || 0,
+                deadline: data.deadline,
+                owner: data.owner,
+                memberCount: data.members?.length || 0,
+            });
+        }
+        catch {
+            /* skip */
+        }
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify({ projects }, null, 2) }],
+    };
+});
+// --- Tool: awp_project_status ---
+server.registerTool("awp_project_status", {
+    title: "Project Status",
+    description: "Get detailed project status including members, tasks, and progress.",
+    inputSchema: {
+        slug: z.string().describe("Project slug"),
+    },
+}, async ({ slug }) => {
+    const root = getWorkspaceRoot();
+    const filePath = join(root, PROJECTS_DIR, `${slug}.md`);
+    try {
+        const raw = await readFile(filePath, "utf-8");
+        const { data, content } = matter(raw);
+        // Load tasks
+        const tasks = [];
+        try {
+            const taskDir = join(root, PROJECTS_DIR, slug, "tasks");
+            const taskFiles = await readdir(taskDir);
+            for (const tf of taskFiles.filter((t) => t.endsWith(".md")).sort()) {
+                try {
+                    const tRaw = await readFile(join(taskDir, tf), "utf-8");
+                    const { data: tData } = matter(tRaw);
+                    tasks.push({
+                        slug: tf.replace(/\.md$/, ""),
+                        title: tData.title,
+                        status: tData.status,
+                        assigneeSlug: tData.assigneeSlug,
+                        priority: tData.priority,
+                        deadline: tData.deadline,
+                        blockedBy: tData.blockedBy || [],
+                    });
+                }
+                catch {
+                    /* skip */
+                }
+            }
+        }
+        catch {
+            /* no tasks */
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ frontmatter: data, body: content.trim(), tasks }, null, 2),
+                },
+            ],
+        };
+    }
+    catch {
+        return {
+            content: [{ type: "text", text: `Project "${slug}" not found.` }],
+            isError: true,
+        };
+    }
+});
+// --- Tool: awp_task_create ---
+server.registerTool("awp_task_create", {
+    title: "Create Task",
+    description: "Create a new task within a project.",
+    inputSchema: {
+        projectSlug: z.string().describe("Project slug"),
+        taskSlug: z.string().describe("Task slug"),
+        title: z.string().optional().describe("Task title"),
+        assignee: z.string().optional().describe("Assignee agent DID"),
+        assigneeSlug: z.string().optional().describe("Assignee reputation profile slug"),
+        priority: z.string().optional().describe("Priority (low, medium, high, critical)"),
+        deadline: z.string().optional().describe("Deadline (ISO 8601 or YYYY-MM-DD)"),
+        blockedBy: z.array(z.string()).optional().describe("Task IDs that block this task"),
+        outputArtifact: z.string().optional().describe("Output artifact slug"),
+        contractSlug: z.string().optional().describe("Associated contract slug"),
+        tags: z.array(z.string()).optional().describe("Tags"),
+    },
+}, async ({ projectSlug, taskSlug, title, assignee, assigneeSlug, priority, deadline, blockedBy, outputArtifact, contractSlug, tags, }) => {
+    const root = getWorkspaceRoot();
+    // Check project exists
+    const projPath = join(root, PROJECTS_DIR, `${projectSlug}.md`);
+    let projData;
+    try {
+        const raw = await readFile(projPath, "utf-8");
+        projData = matter(raw);
+    }
+    catch {
+        return {
+            content: [{ type: "text", text: `Project "${projectSlug}" not found.` }],
+            isError: true,
+        };
+    }
+    const taskDir = join(root, PROJECTS_DIR, projectSlug, "tasks");
+    await mkdir(taskDir, { recursive: true });
+    const taskPath = join(taskDir, `${taskSlug}.md`);
+    if (await fileExists(taskPath)) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Task "${taskSlug}" already exists in project "${projectSlug}".`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    const did = await getAgentDid(root);
+    const now = new Date().toISOString();
+    const taskTitle = title ||
+        taskSlug
+            .split("-")
+            .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+            .join(" ");
+    const data = {
+        awp: AWP_VERSION,
+        cdp: CDP_VERSION,
+        type: "task",
+        id: `task:${projectSlug}/${taskSlug}`,
+        projectId: `project:${projectSlug}`,
+        title: taskTitle,
+        status: "pending",
+        priority: priority || "medium",
+        created: now,
+        blockedBy: blockedBy || [],
+        blocks: [],
+        lastModified: now,
+        modifiedBy: did,
+    };
+    if (assignee)
+        data.assignee = assignee;
+    if (assigneeSlug)
+        data.assigneeSlug = assigneeSlug;
+    if (deadline)
+        data.deadline = deadline;
+    if (outputArtifact)
+        data.outputArtifact = outputArtifact;
+    if (contractSlug)
+        data.contractSlug = contractSlug;
+    if (tags?.length)
+        data.tags = tags;
+    const body = `\n# ${taskTitle}\n\n`;
+    const output = matter.stringify(body, data);
+    await writeFile(taskPath, output, "utf-8");
+    // Update project counts
+    projData.data.taskCount = (projData.data.taskCount || 0) + 1;
+    const projOutput = matter.stringify(projData.content, projData.data);
+    await writeFile(projPath, projOutput, "utf-8");
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Created task "${taskSlug}" in project "${projectSlug}" (status: pending)`,
+            },
+        ],
+    };
+});
+// --- Tool: awp_task_update ---
+server.registerTool("awp_task_update", {
+    title: "Update Task",
+    description: "Update a task's status, assignee, or other fields.",
+    inputSchema: {
+        projectSlug: z.string().describe("Project slug"),
+        taskSlug: z.string().describe("Task slug"),
+        status: z
+            .string()
+            .optional()
+            .describe("New status (pending, in-progress, blocked, review, completed, cancelled)"),
+        assignee: z.string().optional().describe("New assignee DID"),
+        assigneeSlug: z.string().optional().describe("New assignee reputation slug"),
+    },
+}, async ({ projectSlug, taskSlug, status: newStatus, assignee, assigneeSlug }) => {
+    const root = getWorkspaceRoot();
+    const taskPath = join(root, PROJECTS_DIR, projectSlug, "tasks", `${taskSlug}.md`);
+    let taskData;
+    try {
+        const raw = await readFile(taskPath, "utf-8");
+        taskData = matter(raw);
+    }
+    catch {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Task "${taskSlug}" not found in project "${projectSlug}".`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    const did = await getAgentDid(root);
+    const now = new Date().toISOString();
+    const changes = [];
+    if (newStatus) {
+        taskData.data.status = newStatus;
+        changes.push(`status → ${newStatus}`);
+    }
+    if (assignee) {
+        taskData.data.assignee = assignee;
+        changes.push(`assignee → ${assignee}`);
+    }
+    if (assigneeSlug) {
+        taskData.data.assigneeSlug = assigneeSlug;
+        changes.push(`assigneeSlug → ${assigneeSlug}`);
+    }
+    taskData.data.lastModified = now;
+    taskData.data.modifiedBy = did;
+    const output = matter.stringify(taskData.content, taskData.data);
+    await writeFile(taskPath, output, "utf-8");
+    // Update project counts if status changed
+    if (newStatus) {
+        const projPath = join(root, PROJECTS_DIR, `${projectSlug}.md`);
+        try {
+            const projRaw = await readFile(projPath, "utf-8");
+            const projData = matter(projRaw);
+            // Recount completed tasks
+            const taskDir = join(root, PROJECTS_DIR, projectSlug, "tasks");
+            let taskCount = 0;
+            let completedCount = 0;
+            try {
+                const taskFiles = await readdir(taskDir);
+                for (const tf of taskFiles.filter((t) => t.endsWith(".md"))) {
+                    try {
+                        const tRaw = await readFile(join(taskDir, tf), "utf-8");
+                        const { data: tData } = matter(tRaw);
+                        if (tData.type === "task") {
+                            taskCount++;
+                            if (tData.status === "completed")
+                                completedCount++;
+                        }
+                    }
+                    catch {
+                        /* skip */
+                    }
+                }
+            }
+            catch {
+                /* no tasks */
+            }
+            projData.data.taskCount = taskCount;
+            projData.data.completedCount = completedCount;
+            const projOutput = matter.stringify(projData.content, projData.data);
+            await writeFile(projPath, projOutput, "utf-8");
+        }
+        catch {
+            /* project not found */
+        }
+    }
+    return {
+        content: [
+            { type: "text", text: `Updated task "${taskSlug}": ${changes.join(", ")}` },
+        ],
+    };
+});
+// --- Tool: awp_task_list ---
+server.registerTool("awp_task_list", {
+    title: "List Tasks",
+    description: "List all tasks for a project with optional status and assignee filters.",
+    inputSchema: {
+        projectSlug: z.string().describe("Project slug"),
+        status: z.string().optional().describe("Filter by status"),
+        assigneeSlug: z.string().optional().describe("Filter by assignee slug"),
+    },
+}, async ({ projectSlug, status: statusFilter, assigneeSlug }) => {
+    const root = getWorkspaceRoot();
+    const taskDir = join(root, PROJECTS_DIR, projectSlug, "tasks");
+    let files;
+    try {
+        files = await readdir(taskDir);
+    }
+    catch {
+        return {
+            content: [{ type: "text", text: JSON.stringify({ tasks: [] }, null, 2) }],
+        };
+    }
+    const tasks = [];
+    for (const f of files.filter((f) => f.endsWith(".md")).sort()) {
+        try {
+            const raw = await readFile(join(taskDir, f), "utf-8");
+            const { data } = matter(raw);
+            if (data.type !== "task")
+                continue;
+            if (statusFilter && data.status !== statusFilter)
+                continue;
+            if (assigneeSlug && data.assigneeSlug !== assigneeSlug)
+                continue;
+            tasks.push({
+                slug: f.replace(/\.md$/, ""),
+                title: data.title,
+                status: data.status,
+                assigneeSlug: data.assigneeSlug,
+                priority: data.priority,
+                deadline: data.deadline,
+                blockedBy: data.blockedBy || [],
+                blocks: data.blocks || [],
+            });
+        }
+        catch {
+            /* skip */
+        }
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify({ tasks }, null, 2) }],
+    };
+});
+// --- Tool: awp_artifact_merge ---
+server.registerTool("awp_artifact_merge", {
+    title: "Merge Artifacts",
+    description: "Merge a source artifact into a target artifact. Supports 'additive' (append) and 'authority' (reputation-based ordering) strategies.",
+    inputSchema: {
+        targetSlug: z.string().describe("Target artifact slug"),
+        sourceSlug: z.string().describe("Source artifact slug"),
+        strategy: z
+            .string()
+            .optional()
+            .describe("Merge strategy: 'additive' (default) or 'authority'"),
+        message: z.string().optional().describe("Merge message"),
+    },
+}, async ({ targetSlug, sourceSlug, strategy: strat, message }) => {
+    const root = getWorkspaceRoot();
+    const strategy = strat || "additive";
+    if (strategy !== "additive" && strategy !== "authority") {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unknown strategy "${strategy}". Use "additive" or "authority".`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    let targetRaw, sourceRaw;
+    try {
+        targetRaw = await readFile(join(root, ARTIFACTS_DIR, `${targetSlug}.md`), "utf-8");
+    }
+    catch {
+        return {
+            content: [{ type: "text", text: `Target artifact "${targetSlug}" not found.` }],
+            isError: true,
+        };
+    }
+    try {
+        sourceRaw = await readFile(join(root, ARTIFACTS_DIR, `${sourceSlug}.md`), "utf-8");
+    }
+    catch {
+        return {
+            content: [{ type: "text", text: `Source artifact "${sourceSlug}" not found.` }],
+            isError: true,
+        };
+    }
+    const target = matter(targetRaw);
+    const source = matter(sourceRaw);
+    const did = await getAgentDid(root);
+    const now = new Date();
+    const nowIso = now.toISOString();
+    const tfm = target.data;
+    const sfm = source.data;
+    if (strategy === "authority") {
+        // Authority merge using reputation
+        const sharedTags = (tfm.tags || []).filter((t) => (sfm.tags || []).includes(t));
+        const targetAuthor = tfm.authors?.[0] || "anonymous";
+        const sourceAuthor = sfm.authors?.[0] || "anonymous";
+        // Look up reputation scores
+        const getScore = async (authorDid) => {
+            const repDir = join(root, REPUTATION_DIR);
+            try {
+                const repFiles = await readdir(repDir);
+                for (const f of repFiles.filter((f) => f.endsWith(".md"))) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    let data;
+                    try {
+                        const raw = await readFile(join(repDir, f), "utf-8");
+                        ({ data } = matter(raw));
+                    }
+                    catch {
+                        continue; // skip corrupted reputation files
+                    }
+                    if (data.agentDid !== authorDid)
+                        continue;
+                    const MS_PER_MONTH = 30.44 * 24 * 60 * 60 * 1000;
+                    let best = 0;
+                    // Check domain scores for shared tags
+                    for (const tag of sharedTags) {
+                        const dim = data.domainCompetence?.[tag];
+                        if (dim) {
+                            const months = (now.getTime() - new Date(dim.lastSignal).getTime()) / MS_PER_MONTH;
+                            const factor = months > 0 ? Math.exp(-0.02 * months) : 1;
+                            const decayed = 0.5 + (dim.score - 0.5) * factor;
+                            if (decayed > best)
+                                best = decayed;
+                        }
+                    }
+                    // Fallback to reliability
+                    if (best === 0 && data.dimensions?.reliability) {
+                        const dim = data.dimensions.reliability;
+                        const months = (now.getTime() - new Date(dim.lastSignal).getTime()) / MS_PER_MONTH;
+                        const factor = months > 0 ? Math.exp(-0.02 * months) : 1;
+                        best = 0.5 + (dim.score - 0.5) * factor;
+                    }
+                    return best;
+                }
+            }
+            catch {
+                /* no reputation */
+            }
+            return 0;
+        };
+        const targetScore = await getScore(targetAuthor);
+        const sourceScore = await getScore(sourceAuthor);
+        const targetIsHigher = targetScore >= sourceScore;
+        const higherBody = targetIsHigher ? target.content.trim() : source.content.trim();
+        const lowerBody = targetIsHigher ? source.content.trim() : target.content.trim();
+        const lowerAuthor = targetIsHigher ? sourceAuthor : targetAuthor;
+        const lowerScore = targetIsHigher ? sourceScore : targetScore;
+        const higherScore = targetIsHigher ? targetScore : sourceScore;
+        target.content = `\n${higherBody}\n\n---\n*Authority merge: content below from ${lowerAuthor} (authority score: ${lowerScore.toFixed(2)} vs ${higherScore.toFixed(2)})*\n\n${lowerBody}\n`;
+    }
+    else {
+        // Additive merge
+        const separator = `\n---\n*Merged from ${sfm.id} (version ${sfm.version}) on ${nowIso}*\n\n`;
+        target.content += separator + source.content.trim() + "\n";
+    }
+    // Union authors
+    for (const author of sfm.authors || []) {
+        if (!tfm.authors?.includes(author)) {
+            if (!tfm.authors)
+                tfm.authors = [];
+            tfm.authors.push(author);
+        }
+    }
+    if (!tfm.authors?.includes(did)) {
+        if (!tfm.authors)
+            tfm.authors = [];
+        tfm.authors.push(did);
+    }
+    // Union tags
+    if (sfm.tags) {
+        if (!tfm.tags)
+            tfm.tags = [];
+        for (const tag of sfm.tags) {
+            if (!tfm.tags.includes(tag))
+                tfm.tags.push(tag);
+        }
+    }
+    // Confidence: minimum
+    if (tfm.confidence !== undefined && sfm.confidence !== undefined) {
+        tfm.confidence = Math.min(tfm.confidence, sfm.confidence);
+    }
+    else if (sfm.confidence !== undefined) {
+        tfm.confidence = sfm.confidence;
+    }
+    // Bump version + provenance
+    tfm.version = (tfm.version || 1) + 1;
+    tfm.lastModified = nowIso;
+    tfm.modifiedBy = did;
+    if (!tfm.provenance)
+        tfm.provenance = [];
+    tfm.provenance.push({
+        agent: did,
+        action: "merged",
+        timestamp: nowIso,
+        message: message || `Merged from ${sfm.id} (version ${sfm.version}, strategy: ${strategy})`,
+        confidence: tfm.confidence,
+    });
+    const output = matter.stringify(target.content, tfm);
+    await writeFile(join(root, ARTIFACTS_DIR, `${targetSlug}.md`), output, "utf-8");
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Merged ${sfm.id} into ${tfm.id} (now version ${tfm.version}, strategy: ${strategy})`,
+            },
+        ],
+    };
+});
+// --- Tool: awp_read_heartbeat ---
+server.registerTool("awp_read_heartbeat", {
+    title: "Read Heartbeat Config",
+    description: "Read the agent's heartbeat configuration (HEARTBEAT.md)",
+    inputSchema: {},
+}, async () => {
+    const root = getWorkspaceRoot();
+    const path = join(root, "HEARTBEAT.md");
+    try {
+        const raw = await readFile(path, "utf-8");
+        const { data, content } = matter(raw);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ frontmatter: data, body: content.trim() }, null, 2),
+                },
+            ],
+        };
+    }
+    catch {
+        return {
+            content: [{ type: "text", text: "HEARTBEAT.md not found" }],
+            isError: true,
+        };
+    }
+});
+// --- Tool: awp_read_tools ---
+server.registerTool("awp_read_tools", {
+    title: "Read Tools Config",
+    description: "Read the agent's tools configuration (TOOLS.md)",
+    inputSchema: {},
+}, async () => {
+    const root = getWorkspaceRoot();
+    const path = join(root, "TOOLS.md");
+    try {
+        const raw = await readFile(path, "utf-8");
+        const { data, content } = matter(raw);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ frontmatter: data, body: content.trim() }, null, 2),
+                },
+            ],
+        };
+    }
+    catch {
+        return {
+            content: [{ type: "text", text: "TOOLS.md not found" }],
+            isError: true,
+        };
+    }
+});
+// --- Tool: awp_read_agents ---
+server.registerTool("awp_read_agents", {
+    title: "Read Operations/Agents Config",
+    description: "Read the agent's operations configuration (AGENTS.md)",
+    inputSchema: {},
+}, async () => {
+    const root = getWorkspaceRoot();
+    const path = join(root, "AGENTS.md");
+    try {
+        const raw = await readFile(path, "utf-8");
+        const { data, content } = matter(raw);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ frontmatter: data, body: content.trim() }, null, 2),
+                },
+            ],
+        };
+    }
+    catch {
+        return {
+            content: [{ type: "text", text: "AGENTS.md not found" }],
+            isError: true,
+        };
+    }
+});
+// --- Tool: awp_contract_list ---
+server.registerTool("awp_contract_list", {
+    title: "List Delegation Contracts",
+    description: "List all delegation contracts with optional status filter",
+    inputSchema: {
+        status: z
+            .string()
+            .optional()
+            .describe("Filter by status (active, completed, evaluated, cancelled)"),
+    },
+}, async ({ status: statusFilter }) => {
+    const root = getWorkspaceRoot();
+    const contractsDir = join(root, CONTRACTS_DIR);
+    let files;
+    try {
+        files = await readdir(contractsDir);
+    }
+    catch {
+        return {
+            content: [{ type: "text", text: "No contracts directory found." }],
+        };
+    }
+    const mdFiles = files.filter((f) => f.endsWith(".md")).sort();
+    const contracts = [];
+    for (const f of mdFiles) {
+        try {
+            const raw = await readFile(join(contractsDir, f), "utf-8");
+            const { data } = matter(raw);
+            if (data.type === "delegation-contract") {
+                if (!statusFilter || data.status === statusFilter) {
+                    contracts.push({
+                        slug: f.replace(".md", ""),
+                        status: data.status || "unknown",
+                        delegate: data.delegate || "unknown",
+                        delegateSlug: data.delegateSlug || "unknown",
+                        created: data.created || "unknown",
+                        deadline: data.deadline,
+                    });
+                }
+            }
+        }
+        catch {
+            // Skip unparseable files
+        }
+    }
+    if (contracts.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: statusFilter
+                        ? `No contracts with status: ${statusFilter}`
+                        : "No contracts found.",
+                },
+            ],
+        };
+    }
     return {
         content: [
-            { type: "text", text: JSON.stringify(status, null, 2) },
+            {
+                type: "text",
+                text: JSON.stringify(contracts, null, 2),
+            },
         ],
     };
 });