idea-manager 0.2.0 → 0.3.0

package/src/lib/db/queries/projects.ts

@@ -12,14 +12,14 @@ export function getProject(id: string): IProject | undefined {
   return db.prepare('SELECT * FROM projects WHERE id = ?').get(id) as IProject | undefined;
 }
 
-export function createProject(name: string, description: string = ''): IProject {
+export function createProject(name: string, description: string = '', projectPath?: string): IProject {
   const db = getDb();
   const id = generateId();
   const now = new Date().toISOString();
 
   db.prepare(
-    'INSERT INTO projects (id, name, description, created_at, updated_at) VALUES (?, ?, ?, ?, ?)'
-  ).run(id, name, description, now, now);
+    'INSERT INTO projects (id, name, description, project_path, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)'
+  ).run(id, name, description, projectPath ?? null, now, now);
 
   // Also create a default brainstorm
   const brainstormId = generateId();
@@ -30,18 +30,22 @@ export function createProject(name: string, description: string = ''): IProject
   return getProject(id)!;
 }
 
-export function updateProject(id: string, data: { name?: string; description?: string }): IProject | undefined {
+export function updateProject(id: string, data: { name?: string; description?: string; project_path?: string | null }): IProject | undefined {
   const db = getDb();
   const project = getProject(id);
   if (!project) return undefined;
 
-  const name = data.name ?? project.name;
-  const description = data.description ?? project.description;
   const now = new Date().toISOString();
 
   db.prepare(
-    'UPDATE projects SET name = ?, description = ?, updated_at = ? WHERE id = ?'
-  ).run(name, description, now, id);
+    'UPDATE projects SET name = ?, description = ?, project_path = ?, updated_at = ? WHERE id = ?'
+  ).run(
+    data.name ?? project.name,
+    data.description ?? project.description,
+    data.project_path !== undefined ? data.project_path : project.project_path,
+    now,
+    id,
+  );
 
   return getProject(id);
 }

package/src/lib/db/queries/sub-projects.ts

@@ -0,0 +1,122 @@
+import { getDb } from '../index';
+import { generateId } from '../../utils/id';
+import type { ISubProject, ISubProjectWithStats, TaskStatus } from '@/types';
+
+export function getSubProjects(projectId: string): ISubProject[] {
+  const db = getDb();
+  return db.prepare(
+    'SELECT * FROM sub_projects WHERE project_id = ? ORDER BY sort_order ASC'
+  ).all(projectId) as ISubProject[];
+}
+
+export function getSubProject(id: string): ISubProject | undefined {
+  const db = getDb();
+  return db.prepare('SELECT * FROM sub_projects WHERE id = ?').get(id) as ISubProject | undefined;
+}
+
+export function getSubProjectsWithStats(projectId: string): ISubProjectWithStats[] {
+  const db = getDb();
+  const subProjects = db.prepare(
+    'SELECT * FROM sub_projects WHERE project_id = ? ORDER BY sort_order ASC'
+  ).all(projectId) as ISubProject[];
+
+  return subProjects.map(sp => {
+    const stats = db.prepare(`
+      SELECT
+        COUNT(*) as task_count,
+        SUM(CASE WHEN status IN ('submitted','testing') THEN 1 ELSE 0 END) as active_count,
+        SUM(CASE WHEN status IN ('idea','writing') THEN 1 ELSE 0 END) as pending_count,
+        SUM(CASE WHEN status = 'done' THEN 1 ELSE 0 END) as done_count,
+        SUM(CASE WHEN status = 'problem' THEN 1 ELSE 0 END) as problem_count,
+        MAX(updated_at) as last_activity
+      FROM tasks WHERE sub_project_id = ?
+    `).get(sp.id) as {
+      task_count: number;
+      active_count: number;
+      pending_count: number;
+      done_count: number;
+      problem_count: number;
+      last_activity: string | null;
+    };
+
+    const previewTasks = db.prepare(
+      `SELECT title, status FROM tasks WHERE sub_project_id = ?
+       ORDER BY CASE status
+         WHEN 'submitted' THEN 0 WHEN 'testing' THEN 1 WHEN 'writing' THEN 2
+         WHEN 'idea' THEN 3 WHEN 'problem' THEN 4 WHEN 'done' THEN 5
+       END, sort_order ASC LIMIT 5`
+    ).all(sp.id) as { title: string; status: TaskStatus }[];
+
+    return {
+      ...sp,
+      task_count: stats.task_count ?? 0,
+      active_count: stats.active_count ?? 0,
+      pending_count: stats.pending_count ?? 0,
+      done_count: stats.done_count ?? 0,
+      problem_count: stats.problem_count ?? 0,
+      last_activity: stats.last_activity,
+      preview_tasks: previewTasks,
+    };
+  });
+}
+
+export function createSubProject(data: {
+  project_id: string;
+  name: string;
+  description?: string;
+  folder_path?: string;
+}): ISubProject {
+  const db = getDb();
+  const id = generateId();
+  const now = new Date().toISOString();
+
+  const maxOrder = db.prepare(
+    'SELECT MAX(sort_order) as max_order FROM sub_projects WHERE project_id = ?'
+  ).get(data.project_id) as { max_order: number | null };
+  const sortOrder = (maxOrder?.max_order ?? -1) + 1;
+
+  db.prepare(
+    `INSERT INTO sub_projects (id, project_id, name, description, folder_path, sort_order, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(id, data.project_id, data.name, data.description ?? '', data.folder_path ?? null, sortOrder, now, now);
+
+  return getSubProject(id)!;
+}
+
+export function updateSubProject(id: string, data: {
+  name?: string;
+  description?: string;
+  folder_path?: string | null;
+}): ISubProject | undefined {
+  const db = getDb();
+  const sp = getSubProject(id);
+  if (!sp) return undefined;
+
+  const now = new Date().toISOString();
+  db.prepare(
+    'UPDATE sub_projects SET name = ?, description = ?, folder_path = ?, updated_at = ? WHERE id = ?'
+  ).run(
+    data.name ?? sp.name,
+    data.description ?? sp.description,
+    data.folder_path !== undefined ? data.folder_path : sp.folder_path,
+    now,
+    id,
+  );
+
+  return getSubProject(id);
+}
+
+export function deleteSubProject(id: string): boolean {
+  const db = getDb();
+  const result = db.prepare('DELETE FROM sub_projects WHERE id = ?').run(id);
+  return result.changes > 0;
+}
+
+export function reorderSubProjects(projectId: string, orderedIds: string[]): void {
+  const db = getDb();
+  const stmt = db.prepare('UPDATE sub_projects SET sort_order = ? WHERE id = ? AND project_id = ?');
+  const tx = db.transaction(() => {
+    orderedIds.forEach((id, idx) => stmt.run(idx, id, projectId));
+  });
+  tx();
+}

package/src/lib/db/queries/task-conversations.ts

@@ -0,0 +1,27 @@
+import { getDb } from '../index';
+import { generateId } from '../../utils/id';
+import type { ITaskConversation } from '@/types';
+
+export function getTaskConversations(taskId: string): ITaskConversation[] {
+  const db = getDb();
+  return db.prepare(
+    'SELECT * FROM task_conversations WHERE task_id = ? ORDER BY created_at ASC'
+  ).all(taskId) as ITaskConversation[];
+}
+
+export function addTaskConversation(taskId: string, role: 'assistant' | 'user', content: string): ITaskConversation {
+  const db = getDb();
+  const id = generateId();
+  const now = new Date().toISOString();
+
+  db.prepare(
+    'INSERT INTO task_conversations (id, task_id, role, content, created_at) VALUES (?, ?, ?, ?, ?)'
+  ).run(id, taskId, role, content, now);
+
+  return db.prepare('SELECT * FROM task_conversations WHERE id = ?').get(id) as ITaskConversation;
+}
+
+export function deleteTaskConversations(taskId: string): void {
+  const db = getDb();
+  db.prepare('DELETE FROM task_conversations WHERE task_id = ?').run(taskId);
+}

package/src/lib/db/queries/task-prompts.ts

@@ -0,0 +1,32 @@
+import { getDb } from '../index';
+import { generateId } from '../../utils/id';
+import type { ITaskPrompt } from '@/types';
+
+export function getTaskPrompt(taskId: string): ITaskPrompt | undefined {
+  const db = getDb();
+  return db.prepare('SELECT * FROM task_prompts WHERE task_id = ?').get(taskId) as ITaskPrompt | undefined;
+}
+
+export function upsertTaskPrompt(taskId: string, content: string, promptType: 'manual' | 'ai_assisted' = 'manual'): ITaskPrompt {
+  const db = getDb();
+  const existing = getTaskPrompt(taskId);
+  const now = new Date().toISOString();
+
+  if (existing) {
+    db.prepare(
+      'UPDATE task_prompts SET content = ?, prompt_type = ?, updated_at = ? WHERE task_id = ?'
+    ).run(content, promptType, now, taskId);
+  } else {
+    const id = generateId();
+    db.prepare(
+      'INSERT INTO task_prompts (id, task_id, content, prompt_type, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)'
+    ).run(id, taskId, content, promptType, now, now);
+  }
+
+  return getTaskPrompt(taskId)!;
+}
+
+export function deleteTaskPrompt(taskId: string): void {
+  const db = getDb();
+  db.prepare('DELETE FROM task_prompts WHERE task_id = ?').run(taskId);
+}

package/src/lib/db/queries/tasks.ts

@@ -0,0 +1,133 @@
+import { getDb } from '../index';
+import { generateId } from '../../utils/id';
+import type { ITask, TaskStatus, ItemPriority } from '@/types';
+
+interface TaskRow {
+  id: string;
+  project_id: string;
+  sub_project_id: string;
+  title: string;
+  description: string;
+  status: TaskStatus;
+  priority: ItemPriority;
+  is_today: number;
+  sort_order: number;
+  created_at: string;
+  updated_at: string;
+}
+
+function rowToTask(row: TaskRow): ITask {
+  return { ...row, is_today: row.is_today === 1 };
+}
+
+export function getTasks(subProjectId: string): ITask[] {
+  const db = getDb();
+  const rows = db.prepare(
+    'SELECT * FROM tasks WHERE sub_project_id = ? ORDER BY sort_order ASC'
+  ).all(subProjectId) as TaskRow[];
+  return rows.map(rowToTask);
+}
+
+export function getTask(id: string): ITask | undefined {
+  const db = getDb();
+  const row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(id) as TaskRow | undefined;
+  return row ? rowToTask(row) : undefined;
+}
+
+export function getTasksByProject(projectId: string): ITask[] {
+  const db = getDb();
+  const rows = db.prepare(
+    'SELECT * FROM tasks WHERE project_id = ? ORDER BY sort_order ASC'
+  ).all(projectId) as TaskRow[];
+  return rows.map(rowToTask);
+}
+
+export function getTodayTasks(projectId: string): ITask[] {
+  const db = getDb();
+  const rows = db.prepare(
+    'SELECT * FROM tasks WHERE project_id = ? AND is_today = 1 ORDER BY sort_order ASC'
+  ).all(projectId) as TaskRow[];
+  return rows.map(rowToTask);
+}
+
+export function getActiveTasks(projectId: string): ITask[] {
+  const db = getDb();
+  const rows = db.prepare(
+    "SELECT * FROM tasks WHERE project_id = ? AND status IN ('submitted','testing') ORDER BY sort_order ASC"
+  ).all(projectId) as TaskRow[];
+  return rows.map(rowToTask);
+}
+
+export function createTask(data: {
+  project_id: string;
+  sub_project_id: string;
+  title: string;
+  description?: string;
+  status?: TaskStatus;
+  priority?: ItemPriority;
+}): ITask {
+  const db = getDb();
+  const id = generateId();
+  const now = new Date().toISOString();
+
+  const maxOrder = db.prepare(
+    'SELECT MAX(sort_order) as max_order FROM tasks WHERE sub_project_id = ?'
+  ).get(data.sub_project_id) as { max_order: number | null };
+  const sortOrder = (maxOrder?.max_order ?? -1) + 1;
+
+  db.prepare(
+    `INSERT INTO tasks (id, project_id, sub_project_id, title, description, status, priority, is_today, sort_order, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?, ?, ?)`
+  ).run(id, data.project_id, data.sub_project_id, data.title, data.description ?? '', data.status ?? 'idea', data.priority ?? 'medium', sortOrder, now, now);
+
+  return getTask(id)!;
+}
+
+export function updateTask(id: string, data: {
+  title?: string;
+  description?: string;
+  status?: TaskStatus;
+  priority?: ItemPriority;
+  is_today?: boolean;
+  sort_order?: number;
+  sub_project_id?: string;
+}): ITask | undefined {
+  const db = getDb();
+  const row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(id) as TaskRow | undefined;
+  if (!row) return undefined;
+
+  const now = new Date().toISOString();
+  db.prepare(`
+    UPDATE tasks SET
+      title = ?, description = ?, status = ?, priority = ?,
+      is_today = ?, sort_order = ?, sub_project_id = ?, updated_at = ?
+    WHERE id = ?
+  `).run(
+    data.title ?? row.title,
+    data.description ?? row.description,
+    data.status ?? row.status,
+    data.priority ?? row.priority,
+    data.is_today !== undefined ? (data.is_today ? 1 : 0) : row.is_today,
+    data.sort_order ?? row.sort_order,
+    data.sub_project_id ?? row.sub_project_id,
+    now,
+    id,
+  );
+
+  return getTask(id);
+}
+
+export function deleteTask(id: string): boolean {
+  const db = getDb();
+  const result = db.prepare('DELETE FROM tasks WHERE id = ?').run(id);
+  return result.changes > 0;
+}
+
+export function reorderTasks(subProjectId: string, orderedIds: string[]): void {
+  const db = getDb();
+  const stmt = db.prepare('UPDATE tasks SET sort_order = ? WHERE id = ? AND sub_project_id = ?');
+  const tx = db.transaction(() => {
+    orderedIds.forEach((id, idx) => stmt.run(idx, id, subProjectId));
+  });
+  tx();
+}

package/src/lib/db/schema.ts

@@ -6,6 +6,7 @@ export function initSchema(db: Database.Database): void {
       id TEXT PRIMARY KEY,
       name TEXT NOT NULL,
       description TEXT NOT NULL DEFAULT '',
+      project_path TEXT,
       created_at TEXT NOT NULL DEFAULT (datetime('now')),
       updated_at TEXT NOT NULL DEFAULT (datetime('now'))
     );
@@ -31,6 +32,7 @@ export function initSchema(db: Database.Database): void {
       priority TEXT NOT NULL DEFAULT 'medium',
       status TEXT NOT NULL DEFAULT 'pending',
       is_locked INTEGER NOT NULL DEFAULT 1,
+      is_pinned INTEGER NOT NULL DEFAULT 1,
       sort_order INTEGER NOT NULL DEFAULT 0,
       metadata TEXT,
       created_at TEXT NOT NULL DEFAULT (datetime('now')),
@@ -74,5 +76,78 @@ export function initSchema(db: Database.Database): void {
       FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
       FOREIGN KEY (item_id) REFERENCES items(id) ON DELETE CASCADE
     );
+
+    CREATE TABLE IF NOT EXISTS project_context (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL,
+      file_path TEXT NOT NULL,
+      content TEXT NOT NULL,
+      scanned_at TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+    );
+  `);
+
+  // Migrations for existing DBs
+  const itemCols = db.prepare("PRAGMA table_info(items)").all() as { name: string }[];
+  if (!itemCols.some(c => c.name === 'is_pinned')) {
+    db.exec("ALTER TABLE items ADD COLUMN is_pinned INTEGER NOT NULL DEFAULT 1");
+  }
+
+  const projCols = db.prepare("PRAGMA table_info(projects)").all() as { name: string }[];
+  if (!projCols.some(c => c.name === 'project_path')) {
+    db.exec("ALTER TABLE projects ADD COLUMN project_path TEXT");
+  }
+
+  // v2 tables
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sub_projects (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL,
+      name TEXT NOT NULL,
+      description TEXT NOT NULL DEFAULT '',
+      folder_path TEXT,
+      sort_order INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS tasks (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL,
+      sub_project_id TEXT NOT NULL,
+      title TEXT NOT NULL,
+      description TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT 'idea'
+        CHECK(status IN ('idea','writing','submitted','testing','done','problem')),
+      priority TEXT NOT NULL DEFAULT 'medium'
+        CHECK(priority IN ('high','medium','low')),
+      is_today INTEGER NOT NULL DEFAULT 0,
+      sort_order INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
+      FOREIGN KEY (sub_project_id) REFERENCES sub_projects(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS task_prompts (
+      id TEXT PRIMARY KEY,
+      task_id TEXT NOT NULL UNIQUE,
+      content TEXT NOT NULL DEFAULT '',
+      prompt_type TEXT NOT NULL DEFAULT 'manual'
+        CHECK(prompt_type IN ('manual','ai_assisted')),
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY (task_id) REFERENCES tasks(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS task_conversations (
+      id TEXT PRIMARY KEY,
+      task_id TEXT NOT NULL,
+      role TEXT NOT NULL CHECK(role IN ('assistant','user')),
+      content TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY (task_id) REFERENCES tasks(id) ON DELETE CASCADE
+    );
   `);
 }

package/src/lib/mcp/server.ts

@@ -1,24 +1,24 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
-import { getNextTask, getProjectContext, formatItemForMcp, formatTreeForMcp } from '@/lib/mcp/tools';
+import { getNextTask, getProjectContext, formatTaskForMcp, formatProjectForMcp } from '@/lib/mcp/tools';
 import type { McpToolContext } from '@/lib/mcp/tools';
 
 export async function startMcpServer(ctx: McpToolContext) {
   const server = new McpServer({
     name: 'idea-manager',
-    version: '1.0.0',
+    version: '2.0.0',
   });
 
   // Tool 1: list-projects
   server.tool(
     'list-projects',
-    'IM 프로젝트 목록 조회',
+    'List all IM projects',
     {},
     async () => {
       const projects = ctx.listProjects();
       const text = projects.length === 0
-        ? '프로젝트가 없습니다.'
+        ? 'No projects.'
         : projects.map(p => `[${p.id}] ${p.name} - ${p.description}`).join('\n');
       return { content: [{ type: 'text', text }] };
     }
@@ -27,22 +27,22 @@ export async function startMcpServer(ctx: McpToolContext) {
   // Tool 2: get-project-context
   server.tool(
     'get-project-context',
-    '프로젝트 전체 구조와 상태 조회',
-    { projectId: z.string().describe('프로젝트 ID') },
+    'Get project structure: sub-projects, tasks, and stats',
+    { projectId: z.string().describe('Project ID') },
     async ({ projectId }) => {
       const result = getProjectContext(ctx, projectId);
       if (!result.project) {
-        return { content: [{ type: 'text', text: '프로젝트를 찾을 수 없습니다.' }] };
+        return { content: [{ type: 'text', text: 'Project not found.' }] };
       }
 
       const lines = [
-        `프로젝트: ${result.project.name}`,
-        `설명: ${result.project.description}`,
+        `Project: ${result.project.name}`,
+        `Description: ${result.project.description}`,
         '',
-        `전체: ${result.stats.total} | 대기: ${result.stats.pending} | 진행중: ${result.stats.inProgress} | 완료: ${result.stats.done} | 해제됨: ${result.stats.unlocked}`,
+        `Total: ${result.stats.total} | Submitted: ${result.stats.submitted} | Testing: ${result.stats.testing} | Done: ${result.stats.done} | Problem: ${result.stats.problem}`,
         '',
-        '--- 구조 ---',
-        formatTreeForMcp(result.tree),
+        '--- Structure ---',
+        formatProjectForMcp(result.subProjects, result.tasks),
       ];
 
       return { content: [{ type: 'text', text: lines.join('\n') }] };
@@ -52,28 +52,28 @@ export async function startMcpServer(ctx: McpToolContext) {
   // Tool 3: get-next-task
   server.tool(
     'get-next-task',
-    '다음 실행 가능한 작업과 프롬프트 조회 (해제 + 대기 상태)',
-    { projectId: z.string().describe('프로젝트 ID') },
+    'Get next submitted task with its prompt',
+    { projectId: z.string().describe('Project ID') },
     async ({ projectId }) => {
       const result = getNextTask(ctx, projectId);
       if (!result) {
-        return { content: [{ type: 'text', text: '실행 가능한 작업이 없습니다. 항목을 해제(unlock)하세요.' }] };
+        return { content: [{ type: 'text', text: 'No submitted tasks available.' }] };
       }
 
-      const text = formatItemForMcp(result.item, result.prompt);
+      const text = formatTaskForMcp(result.task, result.prompt);
       return { content: [{ type: 'text', text }] };
     }
   );
 
-  // Tool 4: get-prompt
+  // Tool 4: get-task-prompt
   server.tool(
-    'get-prompt',
-    '특정 항목의 프롬프트 조회',
-    { itemId: z.string().describe('항목 ID') },
-    async ({ itemId }) => {
-      const prompt = ctx.getPrompt(itemId);
-      if (!prompt) {
-        return { content: [{ type: 'text', text: '이 항목에 프롬프트가 없습니다. 웹 UI에서 먼저 생성하세요.' }] };
+    'get-task-prompt',
+    'Get prompt for a specific task',
+    { taskId: z.string().describe('Task ID') },
+    async ({ taskId }) => {
+      const prompt = ctx.getTaskPrompt(taskId);
+      if (!prompt?.content) {
+        return { content: [{ type: 'text', text: 'No prompt for this task.' }] };
       }
       return { content: [{ type: 'text', text: prompt.content }] };
     }
@@ -82,36 +82,35 @@ export async function startMcpServer(ctx: McpToolContext) {
   // Tool 5: update-status
   server.tool(
     'update-status',
-    '작업 상태 변경 (pending, in_progress, done)',
+    'Update task status (idea, writing, submitted, testing, done, problem)',
     {
-      itemId: z.string().describe('항목 ID'),
-      status: z.enum(['pending', 'in_progress', 'done']).describe('새 상태'),
+      taskId: z.string().describe('Task ID'),
+      status: z.enum(['idea', 'writing', 'submitted', 'testing', 'done', 'problem']).describe('New status'),
     },
-    async ({ itemId, status }) => {
-      const updated = ctx.updateItem(itemId, { status });
+    async ({ taskId, status }) => {
+      const updated = ctx.updateTask(taskId, { status });
       if (!updated) {
-        return { content: [{ type: 'text', text: '항목을 찾을 수 없습니다.' }] };
+        return { content: [{ type: 'text', text: 'Task not found.' }] };
       }
-      return { content: [{ type: 'text', text: `${updated.title}: 상태가 '${status}'로 변경되었습니다.` }] };
+      return { content: [{ type: 'text', text: `${updated.title}: status changed to '${status}'.` }] };
     }
   );
 
   // Tool 6: report-completion
   server.tool(
     'report-completion',
-    '작업 완료 보고 (상태를 done으로 변경 + 자동 잠금)',
-    { itemId: z.string().describe('항목 ID') },
-    async ({ itemId }) => {
-      const updated = ctx.updateItem(itemId, { status: 'done', is_locked: true });
+    'Report task completion (sets status to done)',
+    { taskId: z.string().describe('Task ID') },
+    async ({ taskId }) => {
+      const updated = ctx.updateTask(taskId, { status: 'done' });
       if (!updated) {
-        return { content: [{ type: 'text', text: '항목을 찾을 수 없습니다.' }] };
+        return { content: [{ type: 'text', text: 'Task not found.' }] };
       }
-      return { content: [{ type: 'text', text: `✅ ${updated.title}: 완료 처리되었습니다. (자동 잠금)` }] };
+      return { content: [{ type: 'text', text: `${updated.title}: completed.` }] };
     }
   );
 
-  // Start server with stdio transport
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error('IM MCP server running on stdio');
+  console.error('IM MCP server v2 running on stdio');
 }