@opsee/mcp-server 0.9.25 → 0.9.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opsee/mcp-server",
-  "version": "0.9.25",
+  "version": "0.9.27",
   "description": "Opsee MCP server — manage projects, tasks, docs, and cycles from AI coding environments",
   "type": "module",
   "bin": {

package/src/__tests__/blocknote-markdown.test.ts

@@ -0,0 +1,92 @@
+import { describe, test, expect } from "vitest";
+import { blockNoteToMarkdown } from "../utils/format.js";
+
+const bn = (blocks: unknown[]) => JSON.stringify(blocks);
+
+const text = (t: string, styles?: Record<string, boolean>) => ({
+  type: "text",
+  text: t,
+  ...(styles ? { styles } : {}),
+});
+
+describe("blockNoteToMarkdown", () => {
+  test("renders paragraphs", () => {
+    expect(blockNoteToMarkdown(bn([{ type: "paragraph", content: [text("hello")] }]))).toBe("hello");
+  });
+
+  test("renders headings, bullets and checkboxes", () => {
+    const md = blockNoteToMarkdown(
+      bn([
+        { type: "heading", props: { level: 2 }, content: [text("Acceptance criteria")] },
+        { type: "checkListItem", props: { checked: true }, content: [text("done")] },
+        { type: "checkListItem", props: { checked: false }, content: [text("todo")] },
+      ]),
+    );
+    expect(md).toContain("## Acceptance criteria");
+    expect(md).toContain("- [x] done");
+    expect(md).toContain("- [ ] todo");
+  });
+
+  test("renders bold, italic and code inline styles", () => {
+    expect(blockNoteToMarkdown(bn([{ type: "paragraph", content: [text("a", { bold: true })] }]))).toBe("**a**");
+    expect(blockNoteToMarkdown(bn([{ type: "paragraph", content: [text("a", { italic: true })] }]))).toBe("*a*");
+    expect(blockNoteToMarkdown(bn([{ type: "paragraph", content: [text("a", { code: true })] }]))).toBe("`a`");
+  });
+
+  test("renders links", () => {
+    const md = blockNoteToMarkdown(
+      bn([{ type: "paragraph", content: [{ type: "link", href: "https://x.test", content: [text("x")] }] }]),
+    );
+    expect(md).toBe("[x](https://x.test)");
+  });
+
+  test("returns the raw string for non-BlockNote input", () => {
+    expect(blockNoteToMarkdown("just markdown")).toBe("just markdown");
+  });
+
+  // Both Go writers persist strikethrough under the BlockNote style key
+  // "strike": backend/service/task.go parseInlineMarkdown and
+  // orchestrator/internal/util/blocknote.go. This reader is what renders an
+  // initiative's coreIdea for get-initiative-context, so dropping the markers
+  // makes an agent read struck-out (abandoned) plan items as live ones.
+  test("preserves strikethrough written by the Go markdown parser", () => {
+    const md = blockNoteToMarkdown(
+      bn([
+        {
+          type: "paragraph",
+          content: [text("Ship "), text("by Friday", { strike: true }), text(" - moved to next cycle")],
+        },
+      ]),
+    );
+    expect(md).toBe("Ship ~~by Friday~~ - moved to next cycle");
+  });
+
+  // The local BNInlineStyle type declares `strikethrough`, so cover that
+  // spelling too - whichever key the pipeline uses, the marker must survive.
+  test("preserves strikethrough under the declared style key", () => {
+    const md = blockNoteToMarkdown(bn([{ type: "paragraph", content: [text("gone", { strikethrough: true })] }]));
+    expect(md).toContain("~~gone~~");
+  });
+
+  test("preserves underline as declared in BNInlineStyle", () => {
+    const md = blockNoteToMarkdown(bn([{ type: "paragraph", content: [text("u", { underline: true })] }]));
+    expect(md).not.toBe("u");
+  });
+
+  test("nests a code block inside a list item on its own indented lines", () => {
+    const md = blockNoteToMarkdown(
+      bn([
+        {
+          type: "bulletListItem",
+          content: [text("run this")],
+          children: [{ type: "codeBlock", props: { language: "sh" }, content: [text("make test\nmake lint")] }],
+        },
+      ]),
+    );
+    const lines = md.split("\n");
+    // Every line of the fenced block body must carry the nesting indent,
+    // otherwise the second command escapes the list item.
+    const bodyLines = lines.filter((l) => l.includes("make "));
+    expect(bodyLines.every((l) => l.startsWith("  "))).toBe(true);
+  });
+});

package/src/__tests__/comments.test.ts

@@ -0,0 +1,193 @@
+import { describe, test, expect, beforeAll, afterAll, beforeEach } from "vitest";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { createServer } from "../server.js";
+import type { ApiClients } from "../client/api.js";
+
+const mockUser = { id: 5, fullName: "Alice Test" };
+
+const mockComment = {
+  id: 11,
+  content: "old text",
+  isInternal: false,
+  taskId: 10,
+  userId: 5,
+  user: mockUser,
+};
+
+// Records the last request each mock method received so tests can assert pass-through.
+let lastAddReq: any = null;
+let lastEditReq: any = null;
+let lastListReq: any = null;
+
+function createMockClients(): ApiClients {
+  lastAddReq = null;
+  lastEditReq = null;
+  lastListReq = null;
+  return {
+    users: {
+      getMe: async () => ({ user: mockUser }),
+    },
+    comments: {
+      getComments: async (req: any) => {
+        lastListReq = req;
+        return { comments: [mockComment] };
+      },
+      getComment: async () => ({ comment: mockComment }),
+      addComment: async (req: any) => {
+        lastAddReq = req;
+        return { comment: { ...mockComment, id: 12, content: req.content, isInternal: req.isInternal, userId: req.userId } };
+      },
+      editComment: async (req: any) => {
+        lastEditReq = req;
+        return { comment: { ...mockComment, content: req.content, isInternal: req.isInternal } };
+      },
+      deleteComment: async () => ({}),
+    },
+  } as unknown as ApiClients;
+}
+
+describe("Comment tools", () => {
+  let client: Client;
+  let cleanup: () => Promise<void>;
+
+  beforeAll(async () => {
+    const [ct, st] = InMemoryTransport.createLinkedPair();
+    const server = createServer(() => createMockClients());
+    await server.connect(st);
+    client = new Client({ name: "comments-test", version: "1.0.0" });
+    await client.connect(ct);
+    cleanup = async () => {
+      await client.close();
+      await server.close();
+    };
+  });
+
+  afterAll(async () => {
+    await cleanup();
+  });
+
+  beforeEach(() => {
+    lastAddReq = null;
+    lastEditReq = null;
+    lastListReq = null;
+  });
+
+  test("opsee_list_comments returns the formatted list", async () => {
+    const result = await client.callTool({
+      name: "opsee_list_comments",
+      arguments: { taskId: 10 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Found 1 comment(s)");
+    expect(text).toContain("old text");
+    expect(text).toContain("Alice Test");
+    expect(lastListReq.taskId).toBe(10);
+  });
+
+  test("opsee_list_comments reports none for an empty result", async () => {
+    const emptyClients = createMockClients();
+    (emptyClients.comments as any).getComments = async () => ({ comments: [] });
+
+    const [ct, st] = InMemoryTransport.createLinkedPair();
+    const server = createServer(() => emptyClients);
+    await server.connect(st);
+    const c = new Client({ name: "empty-comments-test", version: "1.0.0" });
+    await c.connect(ct);
+
+    const result = await c.callTool({
+      name: "opsee_list_comments",
+      arguments: { initiativeId: 2 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("No comments found.");
+
+    await c.close();
+    await server.close();
+  });
+
+  test("opsee_add_comment resolves the current user via getMe and posts the comment", async () => {
+    const result = await client.callTool({
+      name: "opsee_add_comment",
+      arguments: { taskId: 10, content: "new comment" },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Comment added");
+    expect(text).toContain("new comment");
+    expect(lastAddReq.userId).toBe(5);
+    expect(lastAddReq.isInternal).toBe(false);
+  });
+
+  test("opsee_add_comment passes isInternal through", async () => {
+    await client.callTool({
+      name: "opsee_add_comment",
+      arguments: { taskId: 10, content: "internal note", isInternal: true },
+    });
+    expect(lastAddReq.isInternal).toBe(true);
+  });
+
+  test("opsee_add_comment errors when the current user cannot be resolved", async () => {
+    const noUserClients = createMockClients();
+    (noUserClients.users as any).getMe = async () => ({});
+
+    const [ct, st] = InMemoryTransport.createLinkedPair();
+    const server = createServer(() => noUserClients);
+    await server.connect(st);
+    const c = new Client({ name: "no-user-test", version: "1.0.0" });
+    await c.connect(ct);
+
+    const result = await c.callTool({
+      name: "opsee_add_comment",
+      arguments: { taskId: 10, content: "orphan comment" },
+    });
+    expect(result.isError).toBe(true);
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Could not resolve current user");
+
+    await c.close();
+    await server.close();
+  });
+
+  test("opsee_edit_comment looks up the existing comment before editing", async () => {
+    const result = await client.callTool({
+      name: "opsee_edit_comment",
+      arguments: { commentId: 11, content: "edited text" },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Comment updated");
+    expect(text).toContain("edited text");
+    expect(lastEditReq.id).toBe(11);
+    expect(lastEditReq.taskId).toBe(10);
+    expect(lastEditReq.isInternal).toBe(false);
+  });
+
+  test("opsee_edit_comment reports not found when the comment does not exist", async () => {
+    const missingClients = createMockClients();
+    (missingClients.comments as any).getComment = async () => ({});
+
+    const [ct, st] = InMemoryTransport.createLinkedPair();
+    const server = createServer(() => missingClients);
+    await server.connect(st);
+    const c = new Client({ name: "missing-comment-test", version: "1.0.0" });
+    await c.connect(ct);
+
+    const result = await c.callTool({
+      name: "opsee_edit_comment",
+      arguments: { commentId: 999, content: "won't apply" },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Comment not found.");
+
+    await c.close();
+    await server.close();
+  });
+
+  test("opsee_delete_comment succeeds", async () => {
+    const result = await client.callTool({
+      name: "opsee_delete_comment",
+      arguments: { commentId: 11 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Comment deleted.");
+  });
+});

package/src/__tests__/task-dependencies.test.ts

@@ -0,0 +1,173 @@
+import { describe, test, expect, beforeAll, afterAll, beforeEach } from "vitest";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { createServer } from "../server.js";
+import type { ApiClients } from "../client/api.js";
+import { TaskDependencyType } from "../../gen/api/v1/models_pb.js";
+
+const mockDependency = {
+  id: 7,
+  fromTaskId: 10,
+  toTaskId: 11,
+  type: TaskDependencyType.BLOCKS,
+  fromTask: { id: 10, identifier: "TP-1" },
+  toTask: { id: 11, identifier: "TP-2" },
+};
+
+// Records the last request each mock method received so tests can assert pass-through.
+let lastAddReq: any = null;
+let lastListReq: any = null;
+let lastChainReq: any = null;
+
+function createMockClients(): ApiClients {
+  lastAddReq = null;
+  lastListReq = null;
+  lastChainReq = null;
+  return {
+    taskDependencies: {
+      addTaskDependency: async (req: any) => {
+        lastAddReq = req;
+        return { taskDependency: mockDependency };
+      },
+      getTaskDependencies: async (req: any) => {
+        lastListReq = req;
+        return { taskDependencies: [mockDependency] };
+      },
+      deleteTaskDependency: async () => ({}),
+      getDependencyChain: async (req: any) => {
+        lastChainReq = req;
+        return {
+          nodes: [
+            { id: 10, identifier: "TP-1", title: "Fix the bug" },
+            { id: 11, identifier: "TP-2", title: "Write the test" },
+          ],
+          edges: [{ fromTaskId: 10, toTaskId: 11, type: TaskDependencyType.BLOCKS }],
+        };
+      },
+    },
+  } as unknown as ApiClients;
+}
+
+describe("Task dependency tools", () => {
+  let client: Client;
+  let cleanup: () => Promise<void>;
+
+  beforeAll(async () => {
+    const [ct, st] = InMemoryTransport.createLinkedPair();
+    const server = createServer(() => createMockClients());
+    await server.connect(st);
+    client = new Client({ name: "task-dependencies-test", version: "1.0.0" });
+    await client.connect(ct);
+    cleanup = async () => {
+      await client.close();
+      await server.close();
+    };
+  });
+
+  afterAll(async () => {
+    await cleanup();
+  });
+
+  beforeEach(() => {
+    lastAddReq = null;
+    lastListReq = null;
+    lastChainReq = null;
+  });
+
+  test("opsee_create_task_dependency maps type and returns the formatted dependency", async () => {
+    const result = await client.callTool({
+      name: "opsee_create_task_dependency",
+      arguments: { fromTaskId: 10, toTaskId: 11, type: "BLOCKS" },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Task dependency created");
+    expect(text).toContain("TP-1 BLOCKS TP-2");
+    expect(lastAddReq.type).toBe(TaskDependencyType.BLOCKS);
+  });
+
+  test("opsee_create_task_dependency reports failure when backend returns no dependency", async () => {
+    const emptyClients = createMockClients();
+    (emptyClients.taskDependencies as any).addTaskDependency = async () => ({});
+
+    const [ct, st] = InMemoryTransport.createLinkedPair();
+    const server = createServer(() => emptyClients);
+    await server.connect(st);
+    const c = new Client({ name: "empty-add-test", version: "1.0.0" });
+    await c.connect(ct);
+
+    const result = await c.callTool({
+      name: "opsee_create_task_dependency",
+      arguments: { fromTaskId: 10, toTaskId: 11, type: "RELATES_TO" },
+    });
+    expect(result.isError).toBe(true);
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Failed to create task dependency");
+
+    await c.close();
+    await server.close();
+  });
+
+  test("opsee_list_task_dependencies returns the formatted list and default pagination", async () => {
+    const result = await client.callTool({
+      name: "opsee_list_task_dependencies",
+      arguments: { taskId: 10 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Found 1 dependency(ies)");
+    expect(text).toContain("TP-1 BLOCKS TP-2");
+    expect(lastListReq.taskId).toBe(10);
+  });
+
+  test("opsee_list_task_dependencies reports none for an empty result", async () => {
+    const emptyClients = createMockClients();
+    (emptyClients.taskDependencies as any).getTaskDependencies = async () => ({ taskDependencies: [] });
+
+    const [ct, st] = InMemoryTransport.createLinkedPair();
+    const server = createServer(() => emptyClients);
+    await server.connect(st);
+    const c = new Client({ name: "empty-list-test", version: "1.0.0" });
+    await c.connect(ct);
+
+    const result = await c.callTool({
+      name: "opsee_list_task_dependencies",
+      arguments: { taskId: 10 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("No task dependencies found.");
+
+    await c.close();
+    await server.close();
+  });
+
+  test("opsee_delete_task_dependency succeeds", async () => {
+    const result = await client.callTool({
+      name: "opsee_delete_task_dependency",
+      arguments: { dependencyId: 7 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Task dependency deleted.");
+  });
+
+  test("opsee_get_dependency_chain renders nodes and edges with defaults", async () => {
+    const result = await client.callTool({
+      name: "opsee_get_dependency_chain",
+      arguments: { taskId: 10 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("direction: both, depth: 5");
+    expect(text).toContain("2 task(s), 1 edge(s)");
+    expect(text).toContain("[TP-1] Fix the bug");
+    expect(text).toContain("task 10 → task 11 (type");
+    expect(lastChainReq.direction).toBe("both");
+    expect(lastChainReq.depth).toBe(5);
+  });
+
+  test("opsee_get_dependency_chain passes through an explicit direction and depth", async () => {
+    await client.callTool({
+      name: "opsee_get_dependency_chain",
+      arguments: { taskId: 10, direction: "blocked_by", depth: 2 },
+    });
+    expect(lastChainReq.direction).toBe("blocked_by");
+    expect(lastChainReq.depth).toBe(2);
+  });
+});

package/src/__tests__/work-logs.test.ts

@@ -0,0 +1,140 @@
+import { describe, test, expect, beforeAll, afterAll } from "vitest";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { createServer } from "../server.js";
+import type { ApiClients } from "../client/api.js";
+
+const mockTaskWithLogs = {
+  id: 10,
+  identifier: "TP-1",
+  title: "Fix the bug",
+  estimatedHours: 5,
+  workLogs: [
+    { id: 1, userId: 5, user: { fullName: "Alice" }, hours: 2, description: "implemented foo" },
+    { id: 2, userId: 6, hours: 1.5 },
+  ],
+};
+
+function createMockClients(overrides: Partial<ApiClients["tasks"]> = {}): ApiClients {
+  return {
+    tasks: {
+      getTask: async () => ({ task: mockTaskWithLogs }),
+      addWorkLog: async (req: { taskId: number; hours: number }) => ({
+        workLog: { id: 42, taskId: req.taskId, userId: 5, hours: req.hours },
+      }),
+      deleteWorkLog: async () => ({}),
+      ...overrides,
+    },
+  } as unknown as ApiClients;
+}
+
+async function connect(clients: ApiClients) {
+  const [ct, st] = InMemoryTransport.createLinkedPair();
+  const server = createServer(() => clients);
+  await server.connect(st);
+  const client = new Client({ name: "work-logs-test", version: "1.0.0" });
+  await client.connect(ct);
+  return { client, cleanup: async () => { await client.close(); await server.close(); } };
+}
+
+describe("Work log tools", () => {
+  let client: Client;
+  let cleanup: () => Promise<void>;
+
+  beforeAll(async () => {
+    const conn = await connect(createMockClients());
+    client = conn.client;
+    cleanup = conn.cleanup;
+  });
+
+  afterAll(async () => {
+    await cleanup();
+  });
+
+  test("opsee_list_work_logs formats entries, users, and the running total", async () => {
+    const result = await client.callTool({
+      name: "opsee_list_work_logs",
+      arguments: { taskId: 10 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Work logs for TP-1 (total 3.5h)");
+    expect(text).toContain("Alice @");
+    expect(text).toContain("2h — implemented foo (ID: 1)");
+    expect(text).toContain("User #6 @");
+    expect(text).toContain("1.5h (ID: 2)");
+  });
+
+  test("opsee_list_work_logs reports task not found", async () => {
+    const { client: c, cleanup: cl } = await connect(createMockClients({ getTask: async () => ({}) } as any));
+    const result = await c.callTool({
+      name: "opsee_list_work_logs",
+      arguments: { taskId: 999 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Task not found.");
+    await cl();
+  });
+
+  test("opsee_log_work logs hours against a task", async () => {
+    const result = await client.callTool({
+      name: "opsee_log_work",
+      arguments: { taskId: 10, hours: 2.5, description: "implemented foo" },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Logged 2.5h on task 10 (work_log ID 42).");
+  });
+
+  test("opsee_log_work reports failure when the backend returns no work log", async () => {
+    const { client: c, cleanup: cl } = await connect(createMockClients({ addWorkLog: async () => ({}) } as any));
+    const result = await c.callTool({
+      name: "opsee_log_work",
+      arguments: { taskId: 10, hours: 1 },
+    });
+    expect(result.isError).toBe(true);
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Failed to log work");
+    await cl();
+  });
+
+  test("opsee_delete_work_log succeeds", async () => {
+    const result = await client.callTool({
+      name: "opsee_delete_work_log",
+      arguments: { taskId: 10, workLogId: 1 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Work log deleted.");
+  });
+
+  test("opsee_get_task_actual_hours reports over-budget delta", async () => {
+    const result = await client.callTool({
+      name: "opsee_get_task_actual_hours",
+      arguments: { taskId: 10 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    // total logged is 3.5h against an estimate of 5h, so this is under budget.
+    expect(text).toContain("TP-1: 3.5h logged (estimated 5h, under by 1.5 h).");
+  });
+
+  test("opsee_get_task_actual_hours reports over-budget when logged hours exceed the estimate", async () => {
+    const overBudgetTask = { ...mockTaskWithLogs, estimatedHours: 2 };
+    const { client: c, cleanup: cl } = await connect(createMockClients({ getTask: async () => ({ task: overBudgetTask }) } as any));
+    const result = await c.callTool({
+      name: "opsee_get_task_actual_hours",
+      arguments: { taskId: 10 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("TP-1: 3.5h logged (estimated 2h, over by 1.5 h).");
+    await cl();
+  });
+
+  test("opsee_get_task_actual_hours reports task not found", async () => {
+    const { client: c, cleanup: cl } = await connect(createMockClients({ getTask: async () => ({}) } as any));
+    const result = await c.callTool({
+      name: "opsee_get_task_actual_hours",
+      arguments: { taskId: 999 },
+    });
+    const text = (result.content as Array<{ type: string; text: string }>)[0].text;
+    expect(text).toContain("Task not found.");
+    await cl();
+  });
+});

package/src/utils/format.ts

@@ -290,7 +290,18 @@ export function formatTaskDependencyList(deps: TaskDependency[]): string {
 // BlockNote JSON → Markdown
 // ---------------------------------------------------------------------------
 
-type BNInlineStyle = { bold?: boolean; italic?: boolean; underline?: boolean; strikethrough?: boolean; code?: boolean };
+// `strike` is the key the BlockNote default schema uses, and it is what both Go
+// writers persist (backend/service/task.go parseInlineMarkdown and
+// orchestrator/internal/util/blocknote.go). `strikethrough` is accepted too so a
+// payload using the long spelling is not silently dropped.
+type BNInlineStyle = {
+  bold?: boolean;
+  italic?: boolean;
+  underline?: boolean;
+  strike?: boolean;
+  strikethrough?: boolean;
+  code?: boolean;
+};
 type BNTextContent = { type: "text"; text: string; styles?: BNInlineStyle };
 type BNLinkContent = { type: "link"; href: string; content: BNTextContent[] };
 type BNInlineContent = BNTextContent | BNLinkContent;
@@ -314,6 +325,10 @@ function renderInline(content: BNInlineContent[]): string {
     if (t.styles?.code) s = `\`${s}\``;
     if (t.styles?.bold) s = `**${s}**`;
     if (t.styles?.italic) s = `*${s}*`;
+    // Struck-through text usually means "decided against this". Dropping the
+    // markers would present an abandoned plan item as a live one.
+    if (t.styles?.strike || t.styles?.strikethrough) s = `~~${s}~~`;
+    if (t.styles?.underline) s = `<u>${s}</u>`;
     return s;
   }).join("");
 }
@@ -343,7 +358,9 @@ function renderBlock(block: BNBlock, indent: string): string[] {
     case "codeBlock": {
       const lang = (block.props?.language as string) || "";
       lines.push(`${indent}\`\`\`${lang}`);
-      lines.push(`${indent}${inline}`);
+      // A code block's text is one node containing newlines. Indent every line,
+      // not just the first, or the rest escapes the list item it is nested in.
+      for (const body of inline.split("\n")) lines.push(`${indent}${body}`);
       lines.push(`${indent}\`\`\``);
       break;
     }