heyio 0.39.1 → 0.41.0

package/dist/api/server.js

@@ -19,7 +19,7 @@ import { listSchedules, getSchedule, deleteSchedule, setScheduleEnabled } from "
 import { listIoSchedules, getIoSchedule, deleteIoSchedule, setIoScheduleEnabled } from "../store/io-schedules.js";
 import { getScheduleRuns } from "../store/schedule-runs.js";
 import { createFeedEntry, listFeedEntries, listFeedSquads, countUnreadFeedEntries, markFeedEntryRead, markAllFeedEntriesRead, deleteFeedEntry, markFeedEntriesRead, deleteFeedEntries } from "../store/feed.js";
-import { listPages, readPage } from "../wiki/fs.js";
+import { listPages, readPage, writePage, deletePage, assertPagePath } from "../wiki/fs.js";
 import { runScheduleNow } from "../copilot/scheduler.js";
 import { runIoScheduleNow } from "../copilot/io-scheduler.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -958,7 +958,7 @@ export async function startApiServer() {
     });
     api.get("/wiki/*path", (req, res) => {
         try {
-            const pagePath = Array.isArray(req.params.path) ? req.params.path[0] : req.params.path;
+            const pagePath = Array.isArray(req.params.path) ? req.params.path.join("/") : req.params.path;
             if (!pagePath) {
                 res.status(400).json({ error: "Missing page path" });
                 return;
@@ -975,6 +975,100 @@ export async function startApiServer() {
             res.status(500).json({ error: "Failed to read wiki page" });
         }
     });
+    // Create a new wiki page
+    api.post("/wiki", (req, res) => {
+        try {
+            const { path: pagePath, content } = req.body;
+            if (!pagePath || typeof pagePath !== "string") {
+                res.status(400).json({ error: "Missing page path" });
+                return;
+            }
+            if (content === undefined || typeof content !== "string") {
+                res.status(400).json({ error: "Missing page content" });
+                return;
+            }
+            try {
+                assertPagePath(pagePath);
+            }
+            catch (e) {
+                res.status(400).json({ error: e.message });
+                return;
+            }
+            if (readPage(pagePath) !== undefined) {
+                res.status(409).json({ error: "Page already exists" });
+                return;
+            }
+            writePage(pagePath, content);
+            res.status(201).json({ path: pagePath, content });
+        }
+        catch (e) {
+            console.error("Error creating wiki page:", e);
+            res.status(500).json({ error: "Failed to create wiki page" });
+        }
+    });
+    // Update an existing wiki page
+    api.put("/wiki/*path", (req, res) => {
+        try {
+            const pagePath = Array.isArray(req.params.path) ? req.params.path.join("/") : req.params.path;
+            if (!pagePath) {
+                res.status(400).json({ error: "Missing page path" });
+                return;
+            }
+            const { content } = req.body;
+            if (content === undefined || typeof content !== "string") {
+                res.status(400).json({ error: "Missing page content" });
+                return;
+            }
+            try {
+                assertPagePath(pagePath);
+            }
+            catch (e) {
+                res.status(400).json({ error: e.message });
+                return;
+            }
+            if (readPage(pagePath) === undefined) {
+                res.status(404).json({ error: "Page not found" });
+                return;
+            }
+            writePage(pagePath, content);
+            res.json({ path: pagePath, content });
+        }
+        catch (e) {
+            console.error("Error updating wiki page:", e);
+            res.status(500).json({ error: "Failed to update wiki page" });
+        }
+    });
+    // Delete a wiki page
+    api.delete("/wiki/*path", (req, res) => {
+        try {
+            const pagePath = Array.isArray(req.params.path) ? req.params.path.join("/") : req.params.path;
+            if (!pagePath) {
+                res.status(400).json({ error: "Missing page path" });
+                return;
+            }
+            try {
+                assertPagePath(pagePath);
+            }
+            catch (e) {
+                res.status(400).json({ error: e.message });
+                return;
+            }
+            const deleted = deletePage(pagePath);
+            if (!deleted) {
+                res.status(404).json({ error: "Page not found" });
+                return;
+            }
+            res.status(204).send();
+        }
+        catch (e) {
+            console.error("Error deleting wiki page:", e);
+            res.status(500).json({ error: "Failed to delete wiki page" });
+        }
+    });
+    // Get available wiki categories
+    api.get("/wiki-categories", (_req, res) => {
+        res.json({ categories: ["preferences", "projects", "people", "general", "squads"] });
+    });
     // Mount API at /api (for frontend)
     app.use("/api", api);
     // Serve Vue frontend if built assets exist (before backward-compat API mount)

package/dist/api/wiki.test.js

@@ -0,0 +1,283 @@
+/**
+ * Integration tests for Wiki API endpoints (#312).
+ * Tests POST, PUT, DELETE endpoints for wiki pages.
+ */
+import { describe, it, before, after, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import http from "node:http";
+import express from "express";
+import { listPages, readPage, writePage, deletePage, assertPagePath, ensureWikiStructure, } from "../wiki/fs.js";
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function req(method, port, path, body) {
+    return new Promise((resolve, reject) => {
+        const payload = body !== undefined ? JSON.stringify(body) : undefined;
+        const options = {
+            hostname: "127.0.0.1",
+            port,
+            path,
+            method,
+            headers: {
+                ...(payload ? { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(payload) } : {}),
+            },
+        };
+        const r = http.request(options, (res) => {
+            let data = "";
+            res.on("data", (chunk) => { data += chunk; });
+            res.on("end", () => {
+                try {
+                    resolve({ status: res.statusCode ?? 0, body: data ? JSON.parse(data) : {} });
+                }
+                catch {
+                    resolve({ status: res.statusCode ?? 0, body: data });
+                }
+            });
+        });
+        r.on("error", reject);
+        if (payload)
+            r.write(payload);
+        r.end();
+    });
+}
+// ── Server Setup ──────────────────────────────────────────────────────────────
+function createTestServer() {
+    const app = express();
+    app.use(express.json());
+    // Wiki list
+    app.get("/api/wiki", (_req, res) => {
+        try {
+            const pages = listPages();
+            const result = pages.map((pagePath) => {
+                const pageContent = readPage(pagePath);
+                const title = pageContent?.match(/^#\s+(.+)/m)?.[1]?.trim() ?? pagePath;
+                return { path: pagePath, title };
+            });
+            res.json({ pages: result });
+        }
+        catch (e) {
+            res.status(500).json({ error: "Failed to list wiki pages" });
+        }
+    });
+    // Wiki read
+    app.get("/api/wiki/*path", (req, res) => {
+        const pagePath = Array.isArray(req.params.path) ? req.params.path.join("/") : req.params.path;
+        if (!pagePath) {
+            res.status(400).json({ error: "Missing page path" });
+            return;
+        }
+        const pageContent = readPage(pagePath);
+        if (pageContent === undefined) {
+            res.status(404).json({ error: "Page not found" });
+            return;
+        }
+        res.json({ path: pagePath, content: pageContent });
+    });
+    // Wiki create
+    app.post("/api/wiki", (req, res) => {
+        const { path: pagePath, content } = req.body;
+        if (!pagePath || typeof pagePath !== "string") {
+            res.status(400).json({ error: "Missing page path" });
+            return;
+        }
+        if (content === undefined || typeof content !== "string") {
+            res.status(400).json({ error: "Missing page content" });
+            return;
+        }
+        try {
+            assertPagePath(pagePath);
+        }
+        catch (e) {
+            res.status(400).json({ error: e.message });
+            return;
+        }
+        if (readPage(pagePath) !== undefined) {
+            res.status(409).json({ error: "Page already exists" });
+            return;
+        }
+        writePage(pagePath, content);
+        res.status(201).json({ path: pagePath, content });
+    });
+    // Wiki update
+    app.put("/api/wiki/*path", (req, res) => {
+        const pagePath = Array.isArray(req.params.path) ? req.params.path.join("/") : req.params.path;
+        if (!pagePath) {
+            res.status(400).json({ error: "Missing page path" });
+            return;
+        }
+        const { content } = req.body;
+        if (content === undefined || typeof content !== "string") {
+            res.status(400).json({ error: "Missing page content" });
+            return;
+        }
+        try {
+            assertPagePath(pagePath);
+        }
+        catch (e) {
+            res.status(400).json({ error: e.message });
+            return;
+        }
+        if (readPage(pagePath) === undefined) {
+            res.status(404).json({ error: "Page not found" });
+            return;
+        }
+        writePage(pagePath, content);
+        res.json({ path: pagePath, content });
+    });
+    // Wiki delete
+    app.delete("/api/wiki/*path", (req, res) => {
+        const pagePath = Array.isArray(req.params.path) ? req.params.path.join("/") : req.params.path;
+        if (!pagePath) {
+            res.status(400).json({ error: "Missing page path" });
+            return;
+        }
+        try {
+            assertPagePath(pagePath);
+        }
+        catch (e) {
+            res.status(400).json({ error: e.message });
+            return;
+        }
+        const deleted = deletePage(pagePath);
+        if (!deleted) {
+            res.status(404).json({ error: "Page not found" });
+            return;
+        }
+        res.status(204).send();
+    });
+    // Wiki categories
+    app.get("/api/wiki-categories", (_req, res) => {
+        res.json({ categories: ["preferences", "projects", "people", "general", "squads"] });
+    });
+    return app;
+}
+// ── Tests ─────────────────────────────────────────────────────────────────────
+describe("Wiki API Endpoints", () => {
+    let server;
+    let port;
+    const testPagePath = `pages/general/test-wiki-api-${Date.now()}.md`;
+    before(() => {
+        ensureWikiStructure();
+        const app = createTestServer();
+        server = app.listen(0);
+        port = server.address().port;
+    });
+    after(() => {
+        server.close();
+        // Clean up test page if exists
+        try {
+            deletePage(testPagePath);
+        }
+        catch { /* ignore */ }
+    });
+    afterEach(() => {
+        // Clean up test page after each test
+        try {
+            deletePage(testPagePath);
+        }
+        catch { /* ignore */ }
+    });
+    describe("GET /api/wiki", () => {
+        it("returns list of wiki pages", async () => {
+            const { status, body } = await req("GET", port, "/api/wiki");
+            assert.equal(status, 200);
+            assert.ok(Array.isArray(body.pages));
+        });
+    });
+    describe("GET /api/wiki-categories", () => {
+        it("returns available categories", async () => {
+            const { status, body } = await req("GET", port, "/api/wiki-categories");
+            assert.equal(status, 200);
+            const categories = body.categories;
+            assert.ok(categories.includes("general"));
+            assert.ok(categories.includes("projects"));
+            assert.ok(categories.includes("preferences"));
+        });
+    });
+    describe("POST /api/wiki", () => {
+        it("creates a new wiki page", async () => {
+            const { status, body } = await req("POST", port, "/api/wiki", {
+                path: testPagePath,
+                content: "# Test Page\n\nThis is a test.",
+            });
+            assert.equal(status, 201);
+            assert.equal(body.path, testPagePath);
+            // Verify it was created
+            const page = readPage(testPagePath);
+            assert.ok(page?.includes("# Test Page"));
+        });
+        it("returns 409 if page already exists", async () => {
+            writePage(testPagePath, "# Existing");
+            const { status, body } = await req("POST", port, "/api/wiki", {
+                path: testPagePath,
+                content: "# New Content",
+            });
+            assert.equal(status, 409);
+            assert.equal(body.error, "Page already exists");
+        });
+        it("returns 400 for missing path", async () => {
+            const { status } = await req("POST", port, "/api/wiki", {
+                content: "# Test",
+            });
+            assert.equal(status, 400);
+        });
+        it("returns 400 for missing content", async () => {
+            const { status } = await req("POST", port, "/api/wiki", {
+                path: testPagePath,
+            });
+            assert.equal(status, 400);
+        });
+        it("returns 400 for invalid path (not under pages/)", async () => {
+            const { status, body } = await req("POST", port, "/api/wiki", {
+                path: "invalid/path.md",
+                content: "# Test",
+            });
+            assert.equal(status, 400);
+            assert.ok(body.error.includes("pages/"));
+        });
+    });
+    describe("PUT /api/wiki/*path", () => {
+        it("updates an existing wiki page", async () => {
+            writePage(testPagePath, "# Original Content");
+            const { status, body } = await req("PUT", port, `/api/wiki/${testPagePath}`, {
+                content: "# Updated Content\n\nNew text here.",
+            });
+            assert.equal(status, 200);
+            assert.equal(body.path, testPagePath);
+            // Verify it was updated
+            const page = readPage(testPagePath);
+            assert.ok(page?.includes("Updated Content"));
+        });
+        it("returns 404 if page does not exist", async () => {
+            const { status, body } = await req("PUT", port, `/api/wiki/${testPagePath}`, {
+                content: "# New Content",
+            });
+            assert.equal(status, 404);
+            assert.equal(body.error, "Page not found");
+        });
+        it("returns 400 for missing content", async () => {
+            writePage(testPagePath, "# Original");
+            const { status } = await req("PUT", port, `/api/wiki/${testPagePath}`, {});
+            assert.equal(status, 400);
+        });
+    });
+    describe("DELETE /api/wiki/*path", () => {
+        it("deletes an existing wiki page", async () => {
+            writePage(testPagePath, "# To Delete");
+            const { status } = await req("DELETE", port, `/api/wiki/${testPagePath}`);
+            assert.equal(status, 204);
+            // Verify it was deleted
+            const page = readPage(testPagePath);
+            assert.equal(page, undefined);
+        });
+        it("returns 404 if page does not exist", async () => {
+            const { status, body } = await req("DELETE", port, `/api/wiki/${testPagePath}`);
+            assert.equal(status, 404);
+            assert.equal(body.error, "Page not found");
+        });
+        it("returns 400 for invalid path", async () => {
+            const { status, body } = await req("DELETE", port, "/api/wiki/invalid-path.md");
+            assert.equal(status, 400);
+            assert.ok(body.error.includes("pages/"));
+        });
+    });
+});
+//# sourceMappingURL=wiki.test.js.map

package/dist/copilot/agents.js

@@ -376,11 +376,10 @@ export function getActiveAgentTasks() {
  */
 async function getOrCreateAgentSession(squadSlug, agent, taskDescription) {
     const key = agentSessionKey(squadSlug, agent.character_name);
-    // Determine model based on task complexity vs agent's default tier
+    // Determine model: task complexity is sole determinant when task context exists;
+    // stored model_tier is only a fallback for ad-hoc sessions without task context.
     const agentTier = agent.model_tier;
-    const taskTier = taskDescription ? classifyComplexity(taskDescription) : agentTier;
-    const tierRank = { high: 3, medium: 2, low: 1 };
-    const effectiveTier = tierRank[taskTier] >= tierRank[agentTier] ? taskTier : agentTier;
+    const effectiveTier = taskDescription ? classifyComplexity(taskDescription) : agentTier;
     const model = getModelForTier(effectiveTier);
     // If we have a cached session, check if the model matches AND the agent
     // hasn't been left in an error state by a previous task. If either is off,
@@ -422,7 +421,7 @@ async function getOrCreateAgentSession(squadSlug, agent, taskDescription) {
     const wikiSection = wikiPages.length > 0
         ? `\n\n## Squad Wiki\n${wikiPages.map(p => `### ${p.path}\n${p.content}`).join("\n\n")}`
         : "";
-    console.error(`[io] Agent ${agent.character_name}: using model "${model}" (agent tier: ${agentTier}, task tier: ${taskTier}, effective: ${effectiveTier})`);
+    console.error(`[io] Agent ${agent.character_name}: using model "${model}" (stored tier: ${agentTier}, effective: ${effectiveTier})`);
     const universeName = squad.universe
         ? getUniverse(squad.universe)?.name ?? squad.universe
         : "Unknown";

package/dist/copilot/model-router.test.js

@@ -0,0 +1,71 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { classifyComplexity } from "./model-router.js";
+describe("classifyComplexity", () => {
+    describe("high complexity", () => {
+        it("returns high when multiple high keywords are present", () => {
+            assert.equal(classifyComplexity("Refactor and redesign the auth module"), "high");
+        });
+        it("returns high with architect + security keywords", () => {
+            assert.equal(classifyComplexity("Architect a security overhaul"), "high");
+        });
+        it("returns high with debug + investigate", () => {
+            assert.equal(classifyComplexity("Investigate and debug the memory leak"), "high");
+        });
+        it("returns high for performance + optimize", () => {
+            assert.equal(classifyComplexity("Optimize performance of the query engine"), "high");
+        });
+    });
+    describe("low complexity", () => {
+        it("returns low when multiple low keywords are present", () => {
+            assert.equal(classifyComplexity("Read the file and check status"), "low");
+        });
+        it("returns low for simple rename task", () => {
+            assert.equal(classifyComplexity("Simple rename of the variable"), "low");
+        });
+        it("returns low for list + format", () => {
+            assert.equal(classifyComplexity("List all entries and format them"), "low");
+        });
+        it("returns low for delete file + remove file", () => {
+            assert.equal(classifyComplexity("Delete file foo.txt and remove file bar.txt"), "low");
+        });
+    });
+    describe("medium complexity", () => {
+        it("returns medium for ambiguous description with no keywords", () => {
+            assert.equal(classifyComplexity("Update the user profile page"), "medium");
+        });
+        it("returns medium for empty string", () => {
+            assert.equal(classifyComplexity(""), "medium");
+        });
+        it("returns medium when one high and one low keyword tie", () => {
+            // highScore=1, lowScore=1 — both weak, neither wins, falls to default
+            assert.equal(classifyComplexity("Debug and check the output"), "medium");
+        });
+    });
+    describe("weak signal tiebreaker", () => {
+        it("returns high when single high keyword beats zero low keywords", () => {
+            assert.equal(classifyComplexity("Refactor the utils module"), "high");
+        });
+        it("returns low when single low keyword beats zero high keywords", () => {
+            assert.equal(classifyComplexity("Check the build output"), "low");
+        });
+    });
+    describe("case insensitivity", () => {
+        it("matches keywords regardless of case", () => {
+            assert.equal(classifyComplexity("REFACTOR and REDESIGN everything"), "high");
+        });
+        it("matches low keywords in mixed case", () => {
+            assert.equal(classifyComplexity("FORMAT the List of entries"), "low");
+        });
+    });
+    describe("multi-word keywords", () => {
+        it("matches 'delete file' as a single keyword", () => {
+            assert.equal(classifyComplexity("Please delete file and copy file"), "low");
+        });
+        it("does not match partial multi-word keywords", () => {
+            // "delete" alone is not a keyword, only "delete file" is
+            assert.equal(classifyComplexity("Delete the branch"), "medium");
+        });
+    });
+});
+//# sourceMappingURL=model-router.test.js.map

package/dist/copilot/skills.js

@@ -310,4 +310,76 @@ export async function searchSkillsRegistry(query) {
         return [];
     }
 }
+/**
+ * Update a skill's metadata (name and/or description).
+ * Rewrites the SKILL.md file with the updated frontmatter while preserving content.
+ * Throws if the skill doesn't exist.
+ */
+export function updateSkill(slug, updates) {
+    const skillDir = join(SKILLS_DIR, slug);
+    if (!existsSync(skillDir)) {
+        throw new Error(`Skill not found: ${slug}`);
+    }
+    const skillMdPath = join(skillDir, "SKILL.md");
+    if (!existsSync(skillMdPath)) {
+        throw new Error(`SKILL.md not found for skill: ${slug}`);
+    }
+    const currentContent = readFileSync(skillMdPath, "utf-8");
+    const { name: currentName, description: currentDescription } = parseSkillMd(currentContent);
+    // Use provided updates or fall back to current values
+    const newName = updates.name ?? currentName;
+    const newDescription = updates.description ?? currentDescription;
+    // Rebuild SKILL.md with new metadata
+    // Keep everything after the description intact (preserve any extra content)
+    const lines = currentContent.split(/\r?\n/);
+    const newLines = [];
+    // Add the new heading
+    newLines.push(`# ${newName}`);
+    newLines.push("");
+    // Add the new description
+    if (newDescription) {
+        newLines.push(newDescription);
+        newLines.push("");
+    }
+    // Find where the original description ends and append the rest
+    let foundHeading = false;
+    let skippedDescription = false;
+    let blankLinesSeen = 0;
+    for (const line of lines) {
+        if (!foundHeading) {
+            if (line.match(/^#\s+(.+)/)) {
+                foundHeading = true;
+            }
+            continue;
+        }
+        if (!skippedDescription) {
+            if (line.trim() === "") {
+                blankLinesSeen++;
+                if (blankLinesSeen >= 2) {
+                    skippedDescription = true;
+                }
+            }
+            else {
+                blankLinesSeen = 0;
+            }
+            continue;
+        }
+        // We're past the description now
+        newLines.push(line);
+    }
+    const newContent = newLines.join("\n");
+    writeFileSync(skillMdPath, newContent, "utf-8");
+    return {
+        name: newName,
+        slug,
+        description: newDescription,
+        path: skillDir,
+    };
+}
+/**
+ * Delete a skill (alias for removeSkill for consistency with other store modules).
+ */
+export function deleteSkill(slug) {
+    return removeSkill(slug);
+}
 //# sourceMappingURL=skills.js.map

package/dist/copilot/skills.test.js

@@ -0,0 +1,55 @@
+/**
+ * Tests for src/copilot/skills.ts — skill installation, listing, and management.
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { parseSkillUrl, removeSkill, updateSkill, deleteSkill, } from "./skills.js";
+// ── Tests ─────────────────────────────────────────────────────────────────────
+describe("parseSkillUrl", () => {
+    it("parses GitHub blob URLs for SKILL.md", () => {
+        const url = "https://github.com/owner/repo/blob/main/SKILL.md";
+        const result = parseSkillUrl(url);
+        assert.equal(result.type, "file");
+        assert.ok("rawUrl" in result);
+        assert.ok(result.rawUrl.includes("raw.githubusercontent.com"));
+    });
+    it("parses GitHub raw content URLs", () => {
+        const url = "https://raw.githubusercontent.com/owner/repo/main/SKILL.md";
+        const result = parseSkillUrl(url);
+        assert.equal(result.type, "file");
+        assert.ok("rawUrl" in result);
+    });
+    it("parses GitHub repo URLs as repo type", () => {
+        const url = "https://github.com/owner/repo";
+        const result = parseSkillUrl(url);
+        assert.equal(result.type, "repo");
+        assert.equal(result.url, url);
+    });
+    it("rejects non-https SKILL.md URLs", () => {
+        const url = "http://example.com/SKILL.md";
+        assert.throws(() => parseSkillUrl(url));
+    });
+    it("derives slug from repo name with path prefix", () => {
+        const url = "https://github.com/owner/repo/blob/main/skills/ai-chat/SKILL.md";
+        const result = parseSkillUrl(url);
+        assert.equal(result.type, "file");
+        assert.ok(result.slug.includes("repo"));
+    });
+});
+describe("skill store functions", () => {
+    it("exports updateSkill function", () => {
+        assert.ok(typeof updateSkill === "function");
+    });
+    it("exports deleteSkill function", () => {
+        assert.ok(typeof deleteSkill === "function");
+    });
+    it("exports removeSkill function", () => {
+        assert.ok(typeof removeSkill === "function");
+    });
+    it("deleteSkill is callable (alias)", () => {
+        // Just verify these are functions and importable
+        assert.ok(deleteSkill !== undefined);
+        assert.ok(removeSkill !== undefined);
+    });
+});
+//# sourceMappingURL=skills.test.js.map

package/dist/copilot/tools.js

@@ -651,7 +651,7 @@ export function createTools(deps) {
             console.error(`[io] squad_add_agent called: ${slug} — ${role_title}`);
             try {
                 const agent = deps.addSquadAgent(slug, role_title, charter, model_tier);
-                return `Agent added to squad "${slug}":\n- **${agent.character_name}** — ${agent.role_title}\n- Personality: ${agent.personality}\n- Model tier: ${agent.model_tier}`;
+                return `Agent added to squad "${slug}":\n- **${agent.character_name}** — ${agent.role_title}\n- Personality: ${agent.personality}\n- Model: dynamic (task-based)`;
             }
             catch (err) {
                 return `Error adding agent: ${err instanceof Error ? err.message : String(err)}`;
@@ -699,7 +699,7 @@ export function createTools(deps) {
                 const statsStr = st.task_count === 0
                     ? " — 📊 never delegated"
                     : ` — 📊 ${st.task_count} ${st.task_count === 1 ? "task" : "tasks"} · last ${formatRelativeTime(st.last_delegated_at)}`;
-                return `- **${a.character_name}**${leadBadge}${qaBadge} — ${a.role_title} (${a.model_tier}) — ${a.status}${statsStr}${a.personality ? `\n  _${a.personality}_` : ""}`;
+                return `- **${a.character_name}**${leadBadge}${qaBadge} — ${a.role_title} (dynamic) — ${a.status}${statsStr}${a.personality ? `\n  _${a.personality}_` : ""}`;
             });
             const coverage = assessSquadCoverage(agents);
             const coverageBlock = coverage.warning ? `\n\n${coverage.warning}` : "";