@fukuchang/taskchute-mcp 0.1.2 → 0.3.0

package/dist/index.js

@@ -1,13 +1,80 @@
 #!/usr/bin/env node
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Entry } from '@napi-rs/keyring';
 import { argon2id } from 'hash-wasm';
 import '@scure/bip39';
 import '@scure/bip39/wordlists/english.js';
 import { createClient } from '@supabase/supabase-js';
-import { Entry } from '@napi-rs/keyring';
 import { z } from 'zod';
 
+// ../node-shared/src/app-context-error.ts
+var AppContextError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AppContextError";
+  }
+};
+
+// ../node-shared/src/config.ts
+var ENV_URL = "TASKCHUTE_SUPABASE_URL";
+var ENV_KEY = "TASKCHUTE_SUPABASE_PUBLISHABLE_KEY";
+function readSupabaseConfigFromEnv() {
+  const url = process.env.TASKCHUTE_SUPABASE_URL;
+  const publishableKey = process.env.TASKCHUTE_SUPABASE_PUBLISHABLE_KEY;
+  if (!url || !publishableKey) {
+    throw new Error(
+      `Supabase \u306E\u74B0\u5883\u5909\u6570\u304C\u898B\u3064\u304B\u3089\u306A\u3044\u3002${ENV_URL} \u3068 ${ENV_KEY} \u3092\u8A2D\u5B9A\u3057\u3066\u306D\u301C`
+    );
+  }
+  return { url, publishableKey };
+}
+var KEYRING_SERVICE = "taskchute-cli";
+var KEYRING_ACCOUNT = "passphrase";
+var KeyringPassphraseStore = class {
+  get() {
+    try {
+      const entry = new Entry(KEYRING_SERVICE, KEYRING_ACCOUNT);
+      return entry.getPassword();
+    } catch {
+      return null;
+    }
+  }
+  set(passphrase) {
+    const entry = new Entry(KEYRING_SERVICE, KEYRING_ACCOUNT);
+    entry.setPassword(passphrase);
+  }
+  clear() {
+    try {
+      const entry = new Entry(KEYRING_SERVICE, KEYRING_ACCOUNT);
+      entry.deletePassword();
+    } catch {
+    }
+  }
+};
+var KEYRING_SERVICE2 = "taskchute-cli";
+var KeyringSessionStore = class {
+  getItem(key) {
+    try {
+      const entry = new Entry(KEYRING_SERVICE2, key);
+      return entry.getPassword();
+    } catch {
+      return null;
+    }
+  }
+  setItem(key, value) {
+    const entry = new Entry(KEYRING_SERVICE2, key);
+    entry.setPassword(value);
+  }
+  removeItem(key) {
+    try {
+      const entry = new Entry(KEYRING_SERVICE2, key);
+      entry.deletePassword();
+    } catch {
+    }
+  }
+};
+
 // ../crypto/src/bytes.ts
 function allocBytes(length) {
   return new Uint8Array(new ArrayBuffer(length));
@@ -668,6 +735,39 @@ var SupabaseProjectRepository = class {
   }
 };
 
+// ../infra-supabase/src/supabase-routine-expansion-repository.ts
+function rowToExpansion(row) {
+  return {
+    routineId: row.routine_id,
+    date: row.date,
+    status: row.status
+  };
+}
+var SupabaseRoutineExpansionRepository = class {
+  supabase;
+  constructor(supabase) {
+    this.supabase = supabase;
+  }
+  async findByDate(date) {
+    const { data, error } = await this.supabase.from("routine_expansions").select("*").eq("date", date);
+    if (error) throw error;
+    return data.map(rowToExpansion);
+  }
+  async recordExpanded(routineId, date) {
+    const userId = await getCurrentUserId(this.supabase);
+    const { error } = await this.supabase.from("routine_expansions").upsert(
+      {
+        user_id: userId,
+        routine_id: routineId,
+        date,
+        status: "expanded"
+      },
+      { onConflict: "routine_id,date", ignoreDuplicates: true }
+    );
+    if (error) throw error;
+  }
+};
+
 // ../infra-supabase/src/supabase-routine-repository.ts
 async function rowToRoutine(row, cryptoSession) {
   const [title, description] = await Promise.all([
@@ -705,7 +805,6 @@ async function rowToRoutine(row, cryptoSession) {
   }
   if (row.start_date !== null) routine.startDate = row.start_date;
   if (row.end_date !== null) routine.endDate = row.end_date;
-  if (row.last_expanded_date !== null) routine.lastExpandedDate = row.last_expanded_date;
   return routine;
 }
 function nonEncryptedFieldsToRow3(input) {
@@ -727,9 +826,6 @@ function nonEncryptedFieldsToRow3(input) {
   if ("autoExpand" in input && input.autoExpand !== void 0) {
     row.auto_expand = input.autoExpand;
   }
-  if ("lastExpandedDate" in input) {
-    row.last_expanded_date = input.lastExpandedDate ?? null;
-  }
   if ("status" in input && input.status !== void 0) row.status = input.status;
   return row;
 }
@@ -1286,6 +1382,13 @@ var SupabaseTaskRepository = class {
     const { error } = await this.supabase.from("tasks").delete().eq("id", id);
     if (error) throw error;
   }
+  async deleteWithRoutineSkip(id, today) {
+    const { error } = await this.supabase.rpc("delete_task_and_skip_routine", {
+      p_task_id: id,
+      p_today: today
+    });
+    if (error) throw error;
+  }
 };
 
 // ../infra-supabase/src/supabase-time-block-repository.ts
@@ -1495,6 +1598,13 @@ function toDateString(date) {
   const day = String(date.getDate()).padStart(2, "0");
   return `${year}-${month}-${day}`;
 }
+function fromDateString(dateString) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(dateString);
+  if (!match || !match[1] || !match[2] || !match[3]) {
+    throw new Error(`Invalid date string: ${dateString}`);
+  }
+  return new Date(Number(match[1]), Number(match[2]) - 1, Number(match[3]));
+}
 function todayDateString() {
   return toDateString(/* @__PURE__ */ new Date());
 }
@@ -1503,8 +1613,40 @@ function toTimeString(date) {
   const minutes = String(date.getMinutes()).padStart(2, "0");
   return `${hours}:${minutes}`;
 }
+function toTimeStringWithSeconds(date) {
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  const seconds = String(date.getSeconds()).padStart(2, "0");
+  return `${hours}:${minutes}:${seconds}`;
+}
+
+// ../domain/src/task-utils.ts
+function sessionDurationSeconds(session) {
+  return (session.finishedAt.getTime() - session.startedAt.getTime()) / 1e3;
+}
+function completedSessionsTotalSeconds(task) {
+  return task.sessions.reduce((sum, s) => sum + sessionDurationSeconds(s), 0);
+}
+function calculateActualSeconds(task, now = /* @__PURE__ */ new Date()) {
+  const completed = completedSessionsTotalSeconds(task);
+  if (task.currentSession) {
+    return completed + (now.getTime() - task.currentSession.startedAt.getTime()) / 1e3;
+  }
+  return completed;
+}
 
 // ../domain/src/task-operations.ts
+var TIME_RE = /^([01]\d|2[0-3]):([0-5]\d)(?::([0-5]\d))?$/;
+function parseTimeOnDate(dateString, timeString) {
+  const m = TIME_RE.exec(timeString);
+  if (!m || !m[1] || !m[2]) {
+    throw new Error(`Invalid time string: ${timeString}`);
+  }
+  const base = fromDateString(dateString);
+  const seconds = m[3] ? Number(m[3]) : 0;
+  base.setHours(Number(m[1]), Number(m[2]), seconds, 0);
+  return base;
+}
 async function startTask(repo, taskId) {
   const task = await repo.findById(taskId);
   if (!task) throw new Error(`Task not found: ${taskId}`);
@@ -1515,7 +1657,7 @@ async function startTask(repo, taskId) {
     currentSession: { startedAt: now }
   };
   if (!task.actualStartTime) {
-    patch.actualStartTime = toTimeString(now);
+    patch.actualStartTime = toTimeStringWithSeconds(now);
   }
   return repo.update(taskId, patch);
 }
@@ -1535,6 +1677,30 @@ async function pauseTask(repo, taskId) {
     currentSession: void 0
   });
 }
+async function skipTask(repo, taskId) {
+  const task = await repo.findById(taskId);
+  if (!task) throw new Error(`Task not found: ${taskId}`);
+  const updates = { status: "skipped" };
+  if (task.currentSession) {
+    updates.sessions = [
+      ...task.sessions,
+      {
+        startedAt: task.currentSession.startedAt,
+        finishedAt: /* @__PURE__ */ new Date()
+      }
+    ];
+    updates.currentSession = void 0;
+  }
+  return repo.update(taskId, updates);
+}
+async function reopenTask(repo, taskId) {
+  const task = await repo.findById(taskId);
+  if (!task) throw new Error(`Task not found: ${taskId}`);
+  if (task.status !== "completed" && task.status !== "skipped") {
+    return task;
+  }
+  return repo.update(taskId, { status: "planned" });
+}
 async function completeTask(repo, taskId) {
   const task = await repo.findById(taskId);
   if (!task) throw new Error(`Task not found: ${taskId}`);
@@ -1551,6 +1717,115 @@ async function completeTask(repo, taskId) {
   }
   return repo.update(taskId, updates);
 }
+async function interruptTask(repo, params) {
+  const target = await repo.findById(params.targetTaskId);
+  if (!target) throw new Error(`Task not found: ${params.targetTaskId}`);
+  if (!target.currentSession) {
+    throw new Error(`Target task is not currently running`);
+  }
+  const now = /* @__PURE__ */ new Date();
+  const closedSession = {
+    startedAt: target.currentSession.startedAt,
+    finishedAt: now
+  };
+  const finishedOriginal = await repo.update(target.id, {
+    status: "completed",
+    sessions: [...target.sessions, closedSession],
+    currentSession: void 0
+  });
+  const elapsed = calculateActualSeconds(finishedOriginal);
+  const interruptionStartedAt = /* @__PURE__ */ new Date();
+  const interruption = await repo.create({
+    date: target.date,
+    title: params.interruption.title,
+    description: params.interruption.description,
+    estimatedSeconds: params.interruption.estimatedSeconds,
+    sessions: [],
+    currentSession: { startedAt: interruptionStartedAt },
+    status: "running",
+    orderIndex: target.orderIndex + 1,
+    actualStartTime: toTimeStringWithSeconds(interruptionStartedAt),
+    projectId: params.interruption.projectId,
+    contextId: params.interruption.contextId,
+    tagIds: params.interruption.tagIds ?? []
+  });
+  const continuation = await repo.create({
+    date: target.date,
+    title: target.title,
+    description: target.description,
+    estimatedSeconds: Math.max(0, Math.floor(target.estimatedSeconds - elapsed)),
+    sessions: [],
+    status: "planned",
+    orderIndex: target.orderIndex + 2,
+    splitFromTaskId: target.id,
+    projectId: target.projectId,
+    contextId: target.contextId,
+    // continuation は「割り込みが片付いた後にやる残作業」。割り込み発生時刻を
+    // 予定時刻にすることで、(1) interruption と同じ effectiveTime になり、
+    // ソート上 orderIndex で interruption の次に並ぶ、(2) 割り込みが TimeBlock
+    // の境界をまたいだ場合は continuation も新しいブロックに移動する、という
+    // 自然な挙動になる。
+    scheduledStartTime: toTimeString(interruptionStartedAt),
+    tagIds: target.tagIds,
+    isBackground: target.isBackground
+  });
+  return { finishedOriginal, interruption, continuation };
+}
+async function addParallelTask(repo, input) {
+  const startImmediately = input.startImmediately ?? true;
+  const existing = await repo.findByDate(input.date);
+  const maxOrder = existing.reduce((max, t) => t.orderIndex > max ? t.orderIndex : max, 0);
+  const startedAt = startImmediately ? /* @__PURE__ */ new Date() : void 0;
+  return repo.create({
+    date: input.date,
+    title: input.title,
+    description: input.description,
+    estimatedSeconds: input.estimatedSeconds,
+    sessions: [],
+    currentSession: startedAt ? { startedAt } : void 0,
+    status: startImmediately ? "running" : "planned",
+    orderIndex: maxOrder + 10,
+    actualStartTime: startedAt ? toTimeStringWithSeconds(startedAt) : void 0,
+    projectId: input.projectId,
+    contextId: input.contextId,
+    tagIds: input.tagIds ?? [],
+    isBackground: input.isBackground
+  });
+}
+function buildSetActualTimesPatch(task, input) {
+  const startTime = input.startTime?.trim() ? input.startTime.trim() : null;
+  const endTime = input.endTime?.trim() ? input.endTime.trim() : null;
+  if (startTime === null && endTime === null) {
+    return {
+      status: "planned",
+      currentSession: void 0,
+      sessions: [],
+      actualStartTime: void 0
+    };
+  }
+  if (startTime === null && endTime !== null) {
+    throw new Error("endTime requires startTime");
+  }
+  const startedAt = parseTimeOnDate(task.date, startTime);
+  if (endTime === null) {
+    return {
+      status: "running",
+      currentSession: { startedAt },
+      sessions: [],
+      actualStartTime: startTime
+    };
+  }
+  let finishedAt = parseTimeOnDate(task.date, endTime);
+  if (finishedAt.getTime() < startedAt.getTime()) {
+    finishedAt = new Date(finishedAt.getTime() + 24 * 60 * 60 * 1e3);
+  }
+  return {
+    status: "completed",
+    currentSession: void 0,
+    sessions: [{ startedAt, finishedAt }],
+    actualStartTime: startTime
+  };
+}
 
 // ../domain/src/task-reorder.ts
 function computeNextOrderIndex(existingTasks) {
@@ -1562,6 +1837,70 @@ function computeNextOrderIndex(existingTasks) {
   return max + 10;
 }
 
+// ../domain/src/task-suggest.ts
+function normalizeForSearch(str) {
+  return str.trim().toLowerCase().replace(
+    /[ぁ-ゖ]/g,
+    (ch) => String.fromCharCode(ch.charCodeAt(0) + 96)
+  );
+}
+function fuzzyScore(query, target) {
+  const q = query;
+  const t = target;
+  if (q.length === 0) return 0;
+  if (t.length === 0) return null;
+  let qi = 0;
+  let score = 0;
+  let lastMatchIndex = -2;
+  let consecutiveRun = 0;
+  for (let ti = 0; ti < t.length && qi < q.length; ti++) {
+    if (t[ti] === q[qi]) {
+      if (lastMatchIndex === ti - 1) {
+        consecutiveRun += 1;
+        score += 5 + consecutiveRun * 3;
+      } else {
+        consecutiveRun = 0;
+        score += 2;
+      }
+      if (qi === 0) {
+        score += Math.max(0, 8 - ti);
+      }
+      lastMatchIndex = ti;
+      qi += 1;
+    }
+  }
+  if (qi < q.length) return null;
+  score -= Math.max(0, t.length - q.length) / 4;
+  return score;
+}
+function findSimilarTasks(query, tasks, limit = 5) {
+  const q = normalizeForSearch(query);
+  if (q.length === 0) return [];
+  const bestByTitle = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    const titleTrimmed = task.title.trim();
+    if (titleTrimmed.length === 0) continue;
+    const titleNormalized = normalizeForSearch(titleTrimmed);
+    const score = fuzzyScore(q, titleNormalized);
+    if (score === null) continue;
+    const existing = bestByTitle.get(titleNormalized);
+    if (!existing) {
+      bestByTitle.set(titleNormalized, { task, score });
+      continue;
+    }
+    const existingNewer = existing.task.updatedAt.getTime();
+    const candidateNewer = task.updatedAt.getTime();
+    if (candidateNewer > existingNewer) {
+      bestByTitle.set(titleNormalized, { task, score });
+    }
+  }
+  const sorted = Array.from(bestByTitle.values()).sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return b.task.updatedAt.getTime() - a.task.updatedAt.getTime();
+  });
+  return sorted.slice(0, limit).map((s) => s.task);
+}
+
 // ../domain/src/task-change-log.ts
 function describeStatusTransition(from, to) {
   if (from === "planned" && to === "running") return "\u958B\u59CB";
@@ -1796,6 +2135,80 @@ function diffTasksToNoteInputs(before, after, lookups) {
   }
   return result;
 }
+function titleOrPlaceholder(task) {
+  return task.title || "\u7121\u984C\u306E\u30BF\u30B9\u30AF";
+}
+async function interruptTaskWithAudit(taskRepo, taskNoteRepo, params) {
+  const result = await interruptTask(taskRepo, params);
+  const notes = buildSplitNoteInputs(
+    result.finishedOriginal,
+    result.interruption,
+    result.continuation
+  );
+  try {
+    await Promise.all(notes.map((input) => taskNoteRepo.create(input)));
+  } catch (err) {
+    console.error("[audit] failed to record split notes", {
+      sourceTaskId: result.finishedOriginal.id,
+      err
+    });
+  }
+  return result;
+}
+function buildSplitNoteInputs(source, interruption, continuation) {
+  const sourceTitle = titleOrPlaceholder(source);
+  const interruptionTitle = titleOrPlaceholder(interruption);
+  return [
+    {
+      taskId: source.id,
+      type: "split",
+      body: `\u300C${interruptionTitle}\u300D\u306E\u5272\u308A\u8FBC\u307F\u3067\u5206\u5272\u3002\u6B8B\u4F5C\u696D\u306F\u5225\u30BF\u30B9\u30AF\u3067\u7D99\u7D9A\u3002`,
+      metadata: {
+        event: "split-source",
+        interruptionTaskId: interruption.id,
+        continuationTaskId: continuation.id
+      }
+    },
+    {
+      taskId: interruption.id,
+      type: "split",
+      body: `\u300C${sourceTitle}\u300D\u306E\u4F5C\u696D\u4E2D\u306B\u5272\u308A\u8FBC\u307F\u3068\u3057\u3066\u8D77\u7968\u3002`,
+      metadata: {
+        event: "split-interruption",
+        sourceTaskId: source.id,
+        continuationTaskId: continuation.id
+      }
+    },
+    {
+      taskId: continuation.id,
+      type: "split",
+      body: `\u300C${sourceTitle}\u300D\u306E\u6B8B\u4F5C\u696D\u3068\u3057\u3066\u7D99\u7D9A\u3002`,
+      metadata: {
+        event: "split-continuation",
+        sourceTaskId: source.id,
+        interruptionTaskId: interruption.id
+      }
+    }
+  ];
+}
+
+// ../domain/src/routine-expansion.ts
+function buildRoutineTaskPatch(routine) {
+  return {
+    title: routine.title,
+    description: routine.description,
+    estimatedSeconds: routine.estimatedSeconds,
+    projectId: routine.projectId,
+    contextId: routine.contextId,
+    tagIds: routine.tagIds,
+    scheduledStartTime: routine.defaultScheduledStartTime
+  };
+}
+function pickPropagationTargets(routine, tasks, today) {
+  return tasks.filter(
+    (t) => t.routineId === routine.id && t.date >= today && t.status === "planned"
+  );
+}
 
 // ../infra-supabase/src/audit-task-repository.ts
 var AuditingTaskRepository = class {
@@ -1863,17 +2276,23 @@ var AuditingTaskRepository = class {
   delete(id) {
     return this.inner.delete(id);
   }
+  deleteWithRoutineSkip(id, today) {
+    return this.inner.deleteWithRoutineSkip(id, today);
+  }
 };
 
 // ../infra-supabase/src/composition-root.ts
 function buildRepositories(supabaseClient, cryptoSession, getLookups) {
   const taskNote = new SupabaseTaskNoteRepository(supabaseClient, cryptoSession);
   const rawTask = new SupabaseTaskRepository(supabaseClient, cryptoSession);
-  const task = getLookups ? new AuditingTaskRepository(rawTask, taskNote, getLookups) : rawTask;
+  const auditingTask = getLookups ? new AuditingTaskRepository(rawTask, taskNote, getLookups) : void 0;
+  const task = auditingTask ?? rawTask;
   return {
     task,
+    auditingTask,
     taskNote,
     routine: new SupabaseRoutineRepository(supabaseClient, cryptoSession),
+    routineExpansion: new SupabaseRoutineExpansionRepository(supabaseClient),
     project: new SupabaseProjectRepository(supabaseClient, cryptoSession),
     tag: new SupabaseTagRepository(supabaseClient, cryptoSession),
     context: new SupabaseContextRepository(supabaseClient, cryptoSession),
@@ -1881,124 +2300,109 @@ function buildRepositories(supabaseClient, cryptoSession, getLookups) {
   };
 }
 
-// src/config.ts
-var ENV_URL = "TASKCHUTE_SUPABASE_URL";
-var ENV_KEY = "TASKCHUTE_SUPABASE_PUBLISHABLE_KEY";
-function readSupabaseConfigFromEnv() {
-  const url = process.env.TASKCHUTE_SUPABASE_URL;
-  const publishableKey = process.env.TASKCHUTE_SUPABASE_PUBLISHABLE_KEY;
-  if (!url || !publishableKey) {
-    throw new Error(
-      `Supabase \u306E\u74B0\u5883\u5909\u6570\u304C\u898B\u3064\u304B\u3089\u306A\u3044\u3002${ENV_URL} \u3068 ${ENV_KEY} \u3092 MCP server \u306E env \u306B\u8A2D\u5B9A\u3057\u3066\u306D\u301C`
-    );
-  }
-  return { url, publishableKey };
-}
-var KEYRING_SERVICE = "taskchute-cli";
-var KEYRING_ACCOUNT = "passphrase";
-var KeyringPassphraseStore = class {
-  get() {
-    try {
-      const entry = new Entry(KEYRING_SERVICE, KEYRING_ACCOUNT);
-      return entry.getPassword();
-    } catch {
-      return null;
-    }
-  }
-  set(passphrase) {
-    const entry = new Entry(KEYRING_SERVICE, KEYRING_ACCOUNT);
-    entry.setPassword(passphrase);
-  }
-  clear() {
-    try {
-      const entry = new Entry(KEYRING_SERVICE, KEYRING_ACCOUNT);
-      entry.deletePassword();
-    } catch {
-    }
-  }
-};
-var KEYRING_SERVICE2 = "taskchute-cli";
-var KeyringSessionStore = class {
-  getItem(key) {
-    try {
-      const entry = new Entry(KEYRING_SERVICE2, key);
-      return entry.getPassword();
-    } catch {
-      return null;
-    }
-  }
-  setItem(key, value) {
-    const entry = new Entry(KEYRING_SERVICE2, key);
-    entry.setPassword(value);
-  }
-  removeItem(key) {
-    try {
-      const entry = new Entry(KEYRING_SERVICE2, key);
-      entry.deletePassword();
-    } catch {
-    }
-  }
-};
-
-// src/crypto-context.ts
-var McpToolError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "McpToolError";
-  }
-};
-function resolvePassphrase(store) {
+// ../node-shared/src/create-node-app-context.ts
+async function resolvePassphrase(store, promptPassphrase) {
   const envPw = process.env.TASKCHUTE_PASSPHRASE;
   if (envPw) return envPw;
   const stored = store.get();
   if (stored) return stored;
-  throw new McpToolError(
-    "No passphrase available. Set TASKCHUTE_PASSPHRASE env or run `taskchute unlock` from the CLI first."
-  );
+  if (!promptPassphrase) {
+    throw new AppContextError(
+      "No passphrase available. Set TASKCHUTE_PASSPHRASE env or run `taskchute unlock` from the CLI first."
+    );
+  }
+  return await promptPassphrase();
 }
-async function createAppContext(opts = {}) {
+async function createNodeAppContext(opts = {}) {
   const passphraseStore = opts.passphraseStore ?? new KeyringPassphraseStore();
+  const sessionStorage = opts.sessionStorage ?? new KeyringSessionStore();
   const supabase = createNodeSupabaseClient(readSupabaseConfigFromEnv(), {
-    storage: new KeyringSessionStore()
+    storage: sessionStorage
   });
   const {
     data: { user },
     error: authError
   } = await supabase.auth.getUser();
   if (authError || !user || !user.email) {
-    throw new McpToolError(
+    throw new AppContextError(
       "Not logged in. Run `taskchute login` from the CLI first (session is shared via OS keyring)."
     );
   }
   const userKeysRepo = new SupabaseUserKeysRepository(supabase);
   const snapshot = await userKeysRepo.getOwn();
   if (!snapshot) {
-    throw new McpToolError(
+    throw new AppContextError(
       "E2EE not set up. Complete setup from the web app first (Settings \u2192 \u30C7\u30FC\u30BF\u306E\u6697\u53F7\u5316)."
     );
   }
-  const passphrase = resolvePassphrase(passphraseStore);
+  const passphrase = await resolvePassphrase(passphraseStore, opts.promptPassphrase);
   let masterKey;
   try {
     masterKey = await unlockMasterKey(snapshot, { kind: "passphrase", passphrase });
   } catch (err) {
     if (err instanceof UnlockError) {
-      throw new McpToolError(`Unlock failed: ${err.message}`);
+      throw new AppContextError(`Unlock failed: ${err.message}`);
     }
     throw err;
   }
   const cryptoSession = new CryptoSession();
   cryptoSession.setMasterKey(masterKey, snapshot.currentKeyId);
-  const repos = buildRepositories(supabase, cryptoSession);
-  return {
-    supabase,
-    cryptoSession,
-    repos,
+  const lookupsRef = {
+    current: { projects: [], tags: [], contexts: [] }
+  };
+  const repos = buildRepositories(supabase, cryptoSession, () => lookupsRef.current);
+  const refreshLookups = async () => {
+    const [projects, tags, contexts] = await Promise.all([
+      repos.project.findAll(),
+      repos.tag.findAll(),
+      repos.context.findAll()
+    ]);
+    lookupsRef.current = { projects, tags, contexts };
+  };
+  try {
+    await refreshLookups();
+  } catch (err) {
+    console.error("[createNodeAppContext] initial refreshLookups failed:", err);
+  }
+  return {
+    supabase,
+    cryptoSession,
+    repos,
     userId: user.id,
-    email: user.email
+    email: user.email,
+    refreshLookups
   };
 }
 
+// src/crypto-context.ts
+var McpToolError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "McpToolError";
+  }
+};
+async function wrapDomainErrors(op) {
+  try {
+    return await op();
+  } catch (err) {
+    if (err instanceof McpToolError) throw err;
+    if (err instanceof Error) throw new McpToolError(err.message);
+    throw err;
+  }
+}
+async function createAppContext(opts = {}) {
+  try {
+    return await createNodeAppContext({
+      passphraseStore: opts.passphraseStore
+    });
+  } catch (err) {
+    if (err instanceof AppContextError) {
+      throw new McpToolError(err.message);
+    }
+    throw err;
+  }
+}
+
 // src/format/task-summary.ts
 function taskSummaryFrom(task) {
   const summary = {
@@ -2033,15 +2437,81 @@ function taskSummaryFrom(task) {
   return summary;
 }
 
-// src/tools/add-task.ts
+// src/tools/add-parallel-task.ts
+var addParallelTaskInputSchema = z.object({
+  title: z.string().min(1, "title must not be empty"),
+  estimated_seconds: z.number().int().positive(),
+  date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "date must be YYYY-MM-DD").optional().describe("\u5BFE\u8C61\u65E5\u3002\u7701\u7565\u6642\u306F\u4ECA\u65E5"),
+  description: z.string().optional(),
+  project_id: z.string().uuid().optional(),
+  context_id: z.string().uuid().optional(),
+  tag_ids: z.array(z.string().uuid()).optional(),
+  is_background: z.boolean().optional(),
+  start_immediately: z.boolean().optional().describe("true (default) \u3067 running \u72B6\u614B + \u5373\u8A08\u6E2C\u958B\u59CB\u3002false \u3067 planned \u4F5C\u6210\u306E\u307F")
+});
+async function addParallelTaskHandler(ctx, input) {
+  if (input.project_id) {
+    const p = await ctx.repos.project.findById(input.project_id);
+    if (!p) throw new McpToolError(`Project not found: ${input.project_id}`);
+  }
+  if (input.context_id) {
+    const c = await ctx.repos.context.findById(input.context_id);
+    if (!c) throw new McpToolError(`Context not found: ${input.context_id}`);
+  }
+  if (input.tag_ids && input.tag_ids.length > 0) {
+    const checked = await Promise.all(
+      input.tag_ids.map(async (id) => ({
+        id,
+        exists: await ctx.repos.tag.findById(id) !== null
+      }))
+    );
+    const missing = checked.filter((c) => !c.exists).map((c) => c.id);
+    if (missing.length > 0) throw new McpToolError(`Tag(s) not found: ${missing.join(", ")}`);
+  }
+  const task = await addParallelTask(ctx.repos.task, {
+    date: input.date ?? todayDateString(),
+    title: input.title,
+    estimatedSeconds: input.estimated_seconds,
+    ...input.description !== void 0 && { description: input.description },
+    ...input.project_id !== void 0 && { projectId: input.project_id },
+    ...input.context_id !== void 0 && { contextId: input.context_id },
+    ...input.tag_ids !== void 0 && { tagIds: input.tag_ids },
+    ...input.is_background !== void 0 && { isBackground: input.is_background },
+    ...input.start_immediately !== void 0 && { startImmediately: input.start_immediately }
+  });
+  return { task: taskSummaryFrom(task) };
+}
 var addTaskInputSchema = z.object({
   title: z.string().min(1, "title must not be empty"),
   date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "date must be YYYY-MM-DD").optional().describe("\u5BFE\u8C61\u65E5 (YYYY-MM-DD)\u3002\u7701\u7565\u6642\u306F\u30B5\u30FC\u30D0\u30FC\u306E\u4ECA\u65E5 (Asia/Tokyo) \u3092\u4F7F\u3046"),
   estimated_seconds: z.number().int().positive().optional().describe("\u898B\u7A4D\u3082\u308A\u6642\u9593 (\u79D2)\u3002\u7701\u7565\u6642\u306F 1800 (= 30 \u5206)"),
-  description: z.string().optional()
+  description: z.string().optional(),
+  scheduled_start_time: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "scheduled_start_time must be HH:MM").optional().describe("\u4E88\u5B9A\u958B\u59CB\u6642\u523B (HH:MM)\u3002\u30BF\u30A4\u30E0\u30D6\u30ED\u30C3\u30AF / \u30BD\u30FC\u30C8\u9806\u306B\u5F71\u97FF"),
+  project_id: z.string().uuid().optional(),
+  context_id: z.string().uuid().optional(),
+  tag_ids: z.array(z.string().uuid()).optional(),
+  notify_at_scheduled_start: z.boolean().optional().describe("true \u306A\u3089 scheduled_start_time \u5230\u9054\u6642\u306B\u901A\u77E5 (Web \u306E\u307F\u52D5\u4F5C)"),
+  is_background: z.boolean().optional().describe("true \u306A\u3089\u4E26\u884C\u9032\u884C\u4E2D\u306E\u30D0\u30C3\u30AF\u30B0\u30E9\u30A6\u30F3\u30C9\u30BF\u30B9\u30AF\u6271\u3044 (\u898B\u7A4D\u3082\u308A\u96C6\u8A08\u304B\u3089\u9664\u5916)")
 });
 var DEFAULT_ESTIMATED_SECONDS = 30 * 60;
 async function addTaskHandler(ctx, input) {
+  if (input.project_id) {
+    const project = await ctx.repos.project.findById(input.project_id);
+    if (!project) throw new McpToolError(`Project not found: ${input.project_id}`);
+  }
+  if (input.context_id) {
+    const context = await ctx.repos.context.findById(input.context_id);
+    if (!context) throw new McpToolError(`Context not found: ${input.context_id}`);
+  }
+  if (input.tag_ids && input.tag_ids.length > 0) {
+    const checked = await Promise.all(
+      input.tag_ids.map(async (id) => ({ id, exists: await ctx.repos.tag.findById(id) !== null }))
+    );
+    const missing = checked.filter((c) => !c.exists).map((c) => c.id);
+    if (missing.length > 0) {
+      throw new McpToolError(`Tag(s) not found: ${missing.join(", ")}`);
+    }
+  }
   const date = input.date ?? todayDateString();
   const estimatedSeconds = input.estimated_seconds ?? DEFAULT_ESTIMATED_SECONDS;
   const existing = await ctx.repos.task.findByDate(date);
@@ -2054,10 +2524,430 @@ async function addTaskHandler(ctx, input) {
     sessions: [],
     status: "planned",
     orderIndex,
-    tagIds: []
+    tagIds: input.tag_ids ?? [],
+    projectId: input.project_id,
+    contextId: input.context_id,
+    scheduledStartTime: input.scheduled_start_time,
+    notifyAtScheduledStart: input.notify_at_scheduled_start,
+    isBackground: input.is_background
   });
   return { task: taskSummaryFrom(task) };
 }
+
+// src/format/context-summary.ts
+function contextSummaryFrom(context) {
+  const summary = {
+    id: context.id,
+    name: context.name,
+    status: context.status,
+    created_at: context.createdAt.toISOString(),
+    updated_at: context.updatedAt.toISOString()
+  };
+  if (context.description !== void 0) summary.description = context.description;
+  if (context.icon !== void 0) summary.icon = context.icon;
+  if (context.color !== void 0) summary.color = context.color;
+  return summary;
+}
+
+// src/tools/archive-context.ts
+var archiveContextInputSchema = z.object({
+  id: z.string().uuid()
+});
+async function archiveContextHandler(ctx, input) {
+  const existing = await ctx.repos.context.findById(input.id);
+  if (!existing) {
+    throw new McpToolError(`Context not found: ${input.id}`);
+  }
+  const archived = await ctx.repos.context.archive(input.id);
+  return { context: contextSummaryFrom(archived) };
+}
+
+// src/format/project-summary.ts
+function projectSummaryFrom(project) {
+  const summary = {
+    id: project.id,
+    name: project.name,
+    status: project.status,
+    created_at: project.createdAt.toISOString(),
+    updated_at: project.updatedAt.toISOString()
+  };
+  if (project.description !== void 0) summary.description = project.description;
+  if (project.color !== void 0) summary.color = project.color;
+  if (project.parentProjectId !== void 0) summary.parent_project_id = project.parentProjectId;
+  if (project.goalId !== void 0) summary.goal_id = project.goalId;
+  if (project.startedAt !== void 0) summary.started_at = project.startedAt.toISOString();
+  if (project.targetEndDate !== void 0) {
+    summary.target_end_date = project.targetEndDate.toISOString();
+  }
+  if (project.archivedAt !== void 0) summary.archived_at = project.archivedAt.toISOString();
+  return summary;
+}
+
+// src/tools/archive-project.ts
+var archiveProjectInputSchema = z.object({
+  id: z.string().uuid()
+});
+async function archiveProjectHandler(ctx, input) {
+  const existing = await ctx.repos.project.findById(input.id);
+  if (!existing) {
+    throw new McpToolError(`Project not found: ${input.id}`);
+  }
+  const archived = await ctx.repos.project.archive(input.id);
+  return { project: projectSummaryFrom(archived) };
+}
+
+// src/format/routine-summary.ts
+function routineSummaryFrom(routine) {
+  const summary = {
+    id: routine.id,
+    title: routine.title,
+    estimated_seconds: routine.estimatedSeconds,
+    tag_ids: routine.tagIds,
+    frequency: routine.frequency,
+    auto_expand: routine.autoExpand,
+    status: routine.status,
+    created_at: routine.createdAt.toISOString(),
+    updated_at: routine.updatedAt.toISOString()
+  };
+  if (routine.description !== void 0) summary.description = routine.description;
+  if (routine.projectId !== void 0) summary.project_id = routine.projectId;
+  if (routine.contextId !== void 0) summary.context_id = routine.contextId;
+  if (routine.defaultScheduledStartTime !== void 0) {
+    summary.default_scheduled_start_time = routine.defaultScheduledStartTime;
+  }
+  if (routine.startDate !== void 0) summary.start_date = routine.startDate;
+  if (routine.endDate !== void 0) summary.end_date = routine.endDate;
+  return summary;
+}
+
+// src/tools/archive-routine.ts
+var archiveRoutineInputSchema = z.object({
+  id: z.string().uuid()
+});
+async function archiveRoutineHandler(ctx, input) {
+  const existing = await ctx.repos.routine.findById(input.id);
+  if (!existing) {
+    throw new McpToolError(`Routine not found: ${input.id}`);
+  }
+  const archived = await ctx.repos.routine.archive(input.id);
+  return { routine: routineSummaryFrom(archived) };
+}
+
+// src/format/tag-summary.ts
+function tagSummaryFrom(tag) {
+  const summary = {
+    id: tag.id,
+    name: tag.name,
+    status: tag.status,
+    created_at: tag.createdAt.toISOString(),
+    updated_at: tag.updatedAt.toISOString()
+  };
+  if (tag.description !== void 0) summary.description = tag.description;
+  if (tag.color !== void 0) summary.color = tag.color;
+  return summary;
+}
+
+// src/tools/archive-tag.ts
+var archiveTagInputSchema = z.object({
+  id: z.string().uuid()
+});
+async function archiveTagHandler(ctx, input) {
+  const existing = await ctx.repos.tag.findById(input.id);
+  if (!existing) {
+    throw new McpToolError(`Tag not found: ${input.id}`);
+  }
+  const archived = await ctx.repos.tag.archive(input.id);
+  return { tag: tagSummaryFrom(archived) };
+}
+
+// src/format/time-block-summary.ts
+function timeBlockSummaryFrom(timeBlock) {
+  const summary = {
+    id: timeBlock.id,
+    name: timeBlock.name,
+    start_time: timeBlock.startTime,
+    end_time: timeBlock.endTime,
+    weekdays: timeBlock.weekdays,
+    status: timeBlock.status,
+    created_at: timeBlock.createdAt.toISOString(),
+    updated_at: timeBlock.updatedAt.toISOString()
+  };
+  if (timeBlock.defaultProjectId !== void 0) {
+    summary.default_project_id = timeBlock.defaultProjectId;
+  }
+  if (timeBlock.defaultContextId !== void 0) {
+    summary.default_context_id = timeBlock.defaultContextId;
+  }
+  if (timeBlock.defaultTagIds !== void 0) summary.default_tag_ids = timeBlock.defaultTagIds;
+  if (timeBlock.color !== void 0) summary.color = timeBlock.color;
+  if (timeBlock.startDate !== void 0) summary.start_date = timeBlock.startDate;
+  if (timeBlock.endDate !== void 0) summary.end_date = timeBlock.endDate;
+  return summary;
+}
+
+// src/tools/archive-time-block.ts
+var archiveTimeBlockInputSchema = z.object({
+  id: z.string().uuid()
+});
+async function archiveTimeBlockHandler(ctx, input) {
+  const existing = await ctx.repos.timeBlock.findById(input.id);
+  if (!existing) {
+    throw new McpToolError(`TimeBlock not found: ${input.id}`);
+  }
+  const archived = await ctx.repos.timeBlock.archive(input.id);
+  return { time_block: timeBlockSummaryFrom(archived) };
+}
+var createContextInputSchema = z.object({
+  name: z.string().min(1, "name must not be empty"),
+  description: z.string().optional(),
+  icon: z.string().optional().describe("\u7D75\u6587\u5B57\u307E\u305F\u306F\u30A2\u30A4\u30B3\u30F3\u540D (\u4F8B: \u{1F3E0} / mdi-home)"),
+  color: z.string().optional().describe("UI \u8272 (\u4F8B: #ff6b6b)")
+});
+async function createContextHandler(ctx, input) {
+  const createInput = {
+    name: input.name,
+    status: "active"
+  };
+  if (input.description !== void 0) createInput.description = input.description;
+  if (input.icon !== void 0) createInput.icon = input.icon;
+  if (input.color !== void 0) createInput.color = input.color;
+  const context = await ctx.repos.context.create(createInput);
+  return { context: contextSummaryFrom(context) };
+}
+var createProjectInputSchema = z.object({
+  name: z.string().min(1, "name must not be empty"),
+  description: z.string().optional(),
+  color: z.string().optional().describe("UI \u8272 (\u4F8B: #ff6b6b)"),
+  parent_project_id: z.string().uuid().optional(),
+  goal_id: z.string().uuid().optional(),
+  started_at: z.string().datetime().optional().describe("ISO 8601 datetime"),
+  target_end_date: z.string().datetime().optional().describe("ISO 8601 datetime")
+});
+async function createProjectHandler(ctx, input) {
+  if (input.parent_project_id) {
+    const parent = await ctx.repos.project.findById(input.parent_project_id);
+    if (!parent) {
+      throw new McpToolError(`Parent project not found: ${input.parent_project_id}`);
+    }
+  }
+  const createInput = {
+    name: input.name,
+    status: "active"
+  };
+  if (input.description !== void 0) createInput.description = input.description;
+  if (input.color !== void 0) createInput.color = input.color;
+  if (input.parent_project_id !== void 0) createInput.parentProjectId = input.parent_project_id;
+  if (input.goal_id !== void 0) createInput.goalId = input.goal_id;
+  if (input.started_at !== void 0) createInput.startedAt = new Date(input.started_at);
+  if (input.target_end_date !== void 0) {
+    createInput.targetEndDate = new Date(input.target_end_date);
+  }
+  const project = await ctx.repos.project.create(createInput);
+  return { project: projectSummaryFrom(project) };
+}
+var frequencySchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("daily") }),
+  z.object({
+    type: z.literal("weekly"),
+    weekdays: z.array(z.number().int().min(0).max(6)).min(1, "at least 1 weekday")
+  }),
+  z.object({
+    type: z.literal("monthly"),
+    days: z.array(z.number().int().min(1).max(31)).min(1, "at least 1 day")
+  }),
+  z.object({ type: z.literal("custom"), cron: z.string().min(1) })
+]);
+var createRoutineInputSchema = z.object({
+  title: z.string().min(1, "title must not be empty"),
+  description: z.string().optional(),
+  estimated_seconds: z.number().int().positive(),
+  frequency: frequencySchema,
+  project_id: z.string().uuid().optional(),
+  context_id: z.string().uuid().optional(),
+  tag_ids: z.array(z.string().uuid()).optional(),
+  default_scheduled_start_time: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "must be HH:MM").optional(),
+  auto_expand: z.boolean().optional().describe("true \u306A\u3089 Today \u3092\u958B\u3044\u305F\u6642\u306B\u81EA\u52D5\u5C55\u958B (default true)"),
+  start_date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe("\u3053\u306E\u65E5\u4ED8\u4EE5\u964D\u306B\u6709\u52B9\u3002YYYY-MM-DD"),
+  end_date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional()
+});
+async function createRoutineHandler(ctx, input) {
+  if (input.project_id) {
+    const p = await ctx.repos.project.findById(input.project_id);
+    if (!p) throw new McpToolError(`Project not found: ${input.project_id}`);
+  }
+  if (input.context_id) {
+    const c = await ctx.repos.context.findById(input.context_id);
+    if (!c) throw new McpToolError(`Context not found: ${input.context_id}`);
+  }
+  if (input.tag_ids && input.tag_ids.length > 0) {
+    const checked = await Promise.all(
+      input.tag_ids.map(async (id) => ({
+        id,
+        exists: await ctx.repos.tag.findById(id) !== null
+      }))
+    );
+    const missing = checked.filter((c) => !c.exists).map((c) => c.id);
+    if (missing.length > 0) throw new McpToolError(`Tag(s) not found: ${missing.join(", ")}`);
+  }
+  const createInput = {
+    title: input.title,
+    estimatedSeconds: input.estimated_seconds,
+    tagIds: input.tag_ids ?? [],
+    frequency: input.frequency,
+    autoExpand: input.auto_expand ?? true,
+    status: "active"
+  };
+  if (input.description !== void 0) createInput.description = input.description;
+  if (input.project_id !== void 0) createInput.projectId = input.project_id;
+  if (input.context_id !== void 0) createInput.contextId = input.context_id;
+  if (input.default_scheduled_start_time !== void 0) {
+    createInput.defaultScheduledStartTime = input.default_scheduled_start_time;
+  }
+  if (input.start_date !== void 0) createInput.startDate = input.start_date;
+  if (input.end_date !== void 0) createInput.endDate = input.end_date;
+  const routine = await ctx.repos.routine.create(createInput);
+  return { routine: routineSummaryFrom(routine) };
+}
+var createTagInputSchema = z.object({
+  name: z.string().min(1, "name must not be empty"),
+  description: z.string().optional(),
+  color: z.string().optional().describe("UI \u8272 (\u4F8B: #ff6b6b)")
+});
+async function createTagHandler(ctx, input) {
+  const createInput = {
+    name: input.name,
+    status: "active"
+  };
+  if (input.description !== void 0) createInput.description = input.description;
+  if (input.color !== void 0) createInput.color = input.color;
+  const tag = await ctx.repos.tag.create(createInput);
+  return { tag: tagSummaryFrom(tag) };
+}
+var HHMM = /^([01]\d|2[0-3]):[0-5]\d$/;
+var createTimeBlockInputSchema = z.object({
+  name: z.string().min(1, "name must not be empty"),
+  start_time: z.string().regex(HHMM, "start_time must be HH:MM"),
+  end_time: z.string().regex(HHMM, "end_time must be HH:MM"),
+  weekdays: z.array(z.number().int().min(0).max(6)).min(1, "at least 1 weekday"),
+  default_project_id: z.string().uuid().optional(),
+  default_context_id: z.string().uuid().optional(),
+  default_tag_ids: z.array(z.string().uuid()).optional(),
+  color: z.string().optional(),
+  start_date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+  end_date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional()
+});
+async function createTimeBlockHandler(ctx, input) {
+  if (input.default_project_id) {
+    const p = await ctx.repos.project.findById(input.default_project_id);
+    if (!p) throw new McpToolError(`Project not found: ${input.default_project_id}`);
+  }
+  if (input.default_context_id) {
+    const c = await ctx.repos.context.findById(input.default_context_id);
+    if (!c) throw new McpToolError(`Context not found: ${input.default_context_id}`);
+  }
+  if (input.default_tag_ids && input.default_tag_ids.length > 0) {
+    const checked = await Promise.all(
+      input.default_tag_ids.map(async (id) => ({
+        id,
+        exists: await ctx.repos.tag.findById(id) !== null
+      }))
+    );
+    const missing = checked.filter((c) => !c.exists).map((c) => c.id);
+    if (missing.length > 0) throw new McpToolError(`Tag(s) not found: ${missing.join(", ")}`);
+  }
+  const createInput = {
+    name: input.name,
+    startTime: input.start_time,
+    endTime: input.end_time,
+    weekdays: input.weekdays,
+    status: "active"
+  };
+  if (input.default_project_id !== void 0) {
+    createInput.defaultProjectId = input.default_project_id;
+  }
+  if (input.default_context_id !== void 0) {
+    createInput.defaultContextId = input.default_context_id;
+  }
+  if (input.default_tag_ids !== void 0) createInput.defaultTagIds = input.default_tag_ids;
+  if (input.color !== void 0) createInput.color = input.color;
+  if (input.start_date !== void 0) createInput.startDate = input.start_date;
+  if (input.end_date !== void 0) createInput.endDate = input.end_date;
+  const block = await ctx.repos.timeBlock.create(createInput);
+  return { time_block: timeBlockSummaryFrom(block) };
+}
+var deleteContextInputSchema = z.object({
+  id: z.string().uuid()
+});
+async function deleteContextHandler(ctx, input) {
+  const existing = await ctx.repos.context.findById(input.id);
+  if (!existing) {
+    throw new McpToolError(`Context not found: ${input.id}`);
+  }
+  await ctx.repos.context.delete(input.id);
+  return { id: input.id, deleted: true };
+}
+var deleteProjectInputSchema = z.object({
+  id: z.string().uuid()
+});
+async function deleteProjectHandler(ctx, input) {
+  const existing = await ctx.repos.project.findById(input.id);
+  if (!existing) {
+    throw new McpToolError(`Project not found: ${input.id}`);
+  }
+  await ctx.repos.project.delete(input.id);
+  return { id: input.id, deleted: true };
+}
+var deleteRoutineInputSchema = z.object({
+  id: z.string().uuid()
+});
+async function deleteRoutineHandler(ctx, input) {
+  const existing = await ctx.repos.routine.findById(input.id);
+  if (!existing) {
+    throw new McpToolError(`Routine not found: ${input.id}`);
+  }
+  await ctx.repos.routine.delete(input.id);
+  return { id: input.id, deleted: true };
+}
+var deleteTagInputSchema = z.object({
+  id: z.string().uuid()
+});
+async function deleteTagHandler(ctx, input) {
+  const existing = await ctx.repos.tag.findById(input.id);
+  if (!existing) {
+    throw new McpToolError(`Tag not found: ${input.id}`);
+  }
+  await ctx.repos.tag.delete(input.id);
+  return { id: input.id, deleted: true };
+}
+var deleteTaskInputSchema = z.object({
+  id: z.string().uuid({ message: "id must be a UUID" }),
+  hard_delete: z.boolean().optional().describe(
+    "true \u306A\u3089 routine_expansions \u306B skip \u8A18\u9332\u305B\u305A\u7269\u7406\u524A\u9664\u306E\u307F\u3002Routine \u7531\u6765\u30BF\u30B9\u30AF\u3092\u5B8C\u5168\u30EA\u30BB\u30C3\u30C8\u3057\u305F\u3044\u4E0A\u7D1A\u8005\u5411\u3051"
+  )
+});
+async function deleteTaskHandler(ctx, input) {
+  const existing = await ctx.repos.task.findById(input.id);
+  if (!existing) {
+    throw new McpToolError(`Task not found: ${input.id}`);
+  }
+  if (input.hard_delete === true) {
+    await ctx.repos.task.delete(input.id);
+  } else {
+    await ctx.repos.task.deleteWithRoutineSkip(input.id, todayDateString());
+  }
+  return { id: input.id, deleted: true };
+}
+var deleteTimeBlockInputSchema = z.object({
+  id: z.string().uuid()
+});
+async function deleteTimeBlockHandler(ctx, input) {
+  const existing = await ctx.repos.timeBlock.findById(input.id);
+  if (!existing) {
+    throw new McpToolError(`TimeBlock not found: ${input.id}`);
+  }
+  await ctx.repos.timeBlock.delete(input.id);
+  return { id: input.id, deleted: true };
+}
 var doneTaskInputSchema = z.object({
   id: z.string().uuid({ message: "id must be a UUID" })
 });
@@ -2069,6 +2959,127 @@ async function doneTaskHandler(ctx, input) {
   const updated = await completeTask(ctx.repos.task, input.id);
   return { task: taskSummaryFrom(updated) };
 }
+var interruptTaskInputSchema = z.object({
+  target_task_id: z.string().uuid().describe("\u5272\u308A\u8FBC\u307F\u5BFE\u8C61 (running \u4E2D) \u306E\u30BF\u30B9\u30AF id"),
+  title: z.string().min(1, "interruption title must not be empty"),
+  estimated_seconds: z.number().int().positive(),
+  description: z.string().optional(),
+  project_id: z.string().uuid().optional(),
+  context_id: z.string().uuid().optional(),
+  tag_ids: z.array(z.string().uuid()).optional()
+});
+async function interruptTaskHandler(ctx, input) {
+  if (input.project_id) {
+    const p = await ctx.repos.project.findById(input.project_id);
+    if (!p) throw new McpToolError(`Project not found: ${input.project_id}`);
+  }
+  if (input.context_id) {
+    const c = await ctx.repos.context.findById(input.context_id);
+    if (!c) throw new McpToolError(`Context not found: ${input.context_id}`);
+  }
+  if (input.tag_ids && input.tag_ids.length > 0) {
+    const checked = await Promise.all(
+      input.tag_ids.map(async (id) => ({
+        id,
+        exists: await ctx.repos.tag.findById(id) !== null
+      }))
+    );
+    const missing = checked.filter((c) => !c.exists).map((c) => c.id);
+    if (missing.length > 0) throw new McpToolError(`Tag(s) not found: ${missing.join(", ")}`);
+  }
+  const result = await wrapDomainErrors(
+    () => interruptTaskWithAudit(ctx.repos.task, ctx.repos.taskNote, {
+      targetTaskId: input.target_task_id,
+      interruption: {
+        title: input.title,
+        estimatedSeconds: input.estimated_seconds,
+        ...input.description !== void 0 && { description: input.description },
+        ...input.project_id !== void 0 && { projectId: input.project_id },
+        ...input.context_id !== void 0 && { contextId: input.context_id },
+        ...input.tag_ids !== void 0 && { tagIds: input.tag_ids }
+      }
+    })
+  );
+  return {
+    finished_original: taskSummaryFrom(result.finishedOriginal),
+    interruption: taskSummaryFrom(result.interruption),
+    continuation: taskSummaryFrom(result.continuation)
+  };
+}
+var DEFAULT_LIMIT = 100;
+var listContextsInputSchema = z.object({
+  status: z.enum(["active", "archived"]).optional().describe("\u7701\u7565\u6642\u306F active \u306E\u307F"),
+  limit: z.number().int().positive().max(1e3).optional().describe(`\u8FD4\u5374\u4EF6\u6570\u306E\u4E0A\u9650 (default ${DEFAULT_LIMIT})`)
+});
+async function listContextsHandler(ctx, input) {
+  const limit = input.limit ?? DEFAULT_LIMIT;
+  const filter = input.status === void 0 ? { status: "active" } : { status: input.status };
+  const all = await ctx.repos.context.findAll(filter);
+  const truncated = all.length > limit;
+  const contexts = (truncated ? all.slice(0, limit) : all).map(contextSummaryFrom);
+  return { contexts, total: all.length, truncated };
+}
+var DEFAULT_LIMIT2 = 100;
+var listProjectsInputSchema = z.object({
+  status: z.enum(["active", "archived"]).optional().describe('\u7701\u7565\u6642\u306F active \u306E\u307F\u3002"archived" \u3067 archived \u306E\u307F\u3001\u4E21\u65B9\u304C\u8981\u308B\u306A\u3089 2 \u56DE\u547C\u3073\u51FA\u3059'),
+  limit: z.number().int().positive().max(1e3).optional().describe(`\u8FD4\u5374\u4EF6\u6570\u306E\u4E0A\u9650 (default ${DEFAULT_LIMIT2})`)
+});
+async function listProjectsHandler(ctx, input) {
+  const limit = input.limit ?? DEFAULT_LIMIT2;
+  const filter = input.status === void 0 ? { status: "active" } : { status: input.status };
+  const all = await ctx.repos.project.findAll(filter);
+  const truncated = all.length > limit;
+  const projects = (truncated ? all.slice(0, limit) : all).map(projectSummaryFrom);
+  return { projects, total: all.length, truncated };
+}
+var DEFAULT_DAYS = 90;
+var DEFAULT_LIMIT3 = 100;
+var listRecentTasksInputSchema = z.object({
+  days: z.number().int().positive().max(365).optional().describe(`\u4ECA\u65E5\u304B\u3089\u9061\u308B\u65E5\u6570 (default ${DEFAULT_DAYS})`),
+  query: z.string().optional().describe("\u6307\u5B9A\u3059\u308B\u3068 fuzzy match \u3067\u985E\u4F3C\u30BF\u30A4\u30C8\u30EB\u3092\u4E0A\u4F4D\u306B\u8FD4\u3059\u3002\u3072\u3089\u304C\u306A\u2194\u30AB\u30BF\u30AB\u30CA\u6B63\u898F\u5316\u8FBC\u307F"),
+  limit: z.number().int().positive().max(1e3).optional().describe(`\u8FD4\u5374\u4EF6\u6570\u306E\u4E0A\u9650 (default ${DEFAULT_LIMIT3})`)
+});
+async function listRecentTasksHandler(ctx, input) {
+  const days = input.days ?? DEFAULT_DAYS;
+  const limit = input.limit ?? DEFAULT_LIMIT3;
+  const today = todayDateString();
+  const fromDate = (() => {
+    const d = fromDateString(today);
+    d.setDate(d.getDate() - days);
+    return toDateString(d);
+  })();
+  const all = await ctx.repos.task.findFromDate(fromDate);
+  const ordered = input.query ? findSimilarTasks(input.query, all, limit) : [...all].sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+  const truncated = ordered.length > limit;
+  const tasks = (truncated ? ordered.slice(0, limit) : ordered).map(taskSummaryFrom);
+  return { tasks, total: ordered.length, truncated };
+}
+var DEFAULT_LIMIT4 = 100;
+var listRoutinesInputSchema = z.object({
+  status: z.enum(["active", "paused", "archived"]).optional().describe('\u7701\u7565\u6642\u306F active \u306E\u307F\u3002"paused" \u306F\u4E00\u6642\u505C\u6B62\u4E2D (\u5C55\u958B\u505C\u6B62), "archived" \u306F\u5B8C\u5168\u505C\u6B62'),
+  limit: z.number().int().positive().max(1e3).optional().describe(`\u8FD4\u5374\u4EF6\u6570\u306E\u4E0A\u9650 (default ${DEFAULT_LIMIT4})`)
+});
+async function listRoutinesHandler(ctx, input) {
+  const limit = input.limit ?? DEFAULT_LIMIT4;
+  const filter = input.status === void 0 ? { status: "active" } : { status: input.status };
+  const all = await ctx.repos.routine.findAll(filter);
+  const truncated = all.length > limit;
+  const routines = (truncated ? all.slice(0, limit) : all).map(routineSummaryFrom);
+  return { routines, total: all.length, truncated };
+}
+var DEFAULT_LIMIT5 = 100;
+var listTagsInputSchema = z.object({
+  status: z.enum(["active", "archived"]).optional().describe("\u7701\u7565\u6642\u306F active \u306E\u307F"),
+  limit: z.number().int().positive().max(1e3).optional().describe(`\u8FD4\u5374\u4EF6\u6570\u306E\u4E0A\u9650 (default ${DEFAULT_LIMIT5})`)
+});
+async function listTagsHandler(ctx, input) {
+  const limit = input.limit ?? DEFAULT_LIMIT5;
+  const filter = input.status === void 0 ? { status: "active" } : { status: input.status };
+  const all = await ctx.repos.tag.findAll(filter);
+  const truncated = all.length > limit;
+  const tags = (truncated ? all.slice(0, limit) : all).map(tagSummaryFrom);
+  return { tags, total: all.length, truncated };
+}
 var listTasksInputSchema = z.object({
   date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "date must be YYYY-MM-DD").optional().describe("\u5BFE\u8C61\u65E5 (YYYY-MM-DD)\u3002\u7701\u7565\u6642\u306F\u30B5\u30FC\u30D0\u30FC\u306E\u4ECA\u65E5 (Asia/Tokyo) \u3092\u4F7F\u3046")
 });
@@ -2077,6 +3088,19 @@ async function listTasksHandler(ctx, input) {
   const tasks = await ctx.repos.task.findByDate(date);
   return { date, tasks: tasks.map(taskSummaryFrom) };
 }
+var DEFAULT_LIMIT6 = 100;
+var listTimeBlocksInputSchema = z.object({
+  status: z.enum(["active", "archived"]).optional().describe("\u7701\u7565\u6642\u306F active \u306E\u307F"),
+  limit: z.number().int().positive().max(1e3).optional().describe(`\u8FD4\u5374\u4EF6\u6570\u306E\u4E0A\u9650 (default ${DEFAULT_LIMIT6})`)
+});
+async function listTimeBlocksHandler(ctx, input) {
+  const limit = input.limit ?? DEFAULT_LIMIT6;
+  const filter = input.status === void 0 ? { status: "active" } : { status: input.status };
+  const all = await ctx.repos.timeBlock.findAll(filter);
+  const truncated = all.length > limit;
+  const blocks = (truncated ? all.slice(0, limit) : all).map(timeBlockSummaryFrom);
+  return { time_blocks: blocks, total: all.length, truncated };
+}
 var pauseTaskInputSchema = z.object({
   id: z.string().uuid({ message: "id must be a UUID" })
 });
@@ -2088,6 +3112,69 @@ async function pauseTaskHandler(ctx, input) {
   const updated = await pauseTask(ctx.repos.task, input.id);
   return { task: taskSummaryFrom(updated) };
 }
+var reopenTaskInputSchema = z.object({
+  id: z.string().uuid({ message: "id must be a UUID" })
+});
+async function reopenTaskHandler(ctx, input) {
+  const existing = await ctx.repos.task.findById(input.id);
+  if (!existing) {
+    throw new McpToolError(`Task not found: ${input.id}`);
+  }
+  const updated = await reopenTask(ctx.repos.task, input.id);
+  return { task: taskSummaryFrom(updated) };
+}
+var reorderTaskInputSchema = z.object({
+  id: z.string().uuid(),
+  order_index: z.number().int(),
+  scheduled_start_time: z.union([z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "must be HH:MM"), z.null()]).optional().describe(
+    "\u6307\u5B9A\u3059\u308B\u3068\u540C\u6642\u306B\u66F8\u304D\u63DB\u3048\u308B\u3002null=\u672A\u5272\u5F53\u30B0\u30EB\u30FC\u30D7\u306B\u79FB\u52D5\u3002HH:MM=\u8A72\u5F53\u30D6\u30ED\u30C3\u30AF\u306B\u79FB\u52D5\u3002\u7701\u7565=\u5909\u66F4\u306A\u3057"
+  )
+});
+async function reorderTaskHandler(ctx, input) {
+  const existing = await ctx.repos.task.findById(input.id);
+  if (!existing) {
+    throw new McpToolError(`Task not found: ${input.id}`);
+  }
+  const patch = { orderIndex: input.order_index };
+  if (input.scheduled_start_time !== void 0) {
+    patch.scheduledStartTime = input.scheduled_start_time === null ? void 0 : input.scheduled_start_time;
+  }
+  const updated = await ctx.repos.task.update(input.id, patch);
+  return { task: taskSummaryFrom(updated) };
+}
+var ACTUAL_TIME_RE = /^([01]\d|2[0-3]):[0-5]\d(?::[0-5]\d)?$/;
+var setActualTimesInputSchema = z.object({
+  id: z.string().uuid(),
+  start_time: z.union([z.string().regex(ACTUAL_TIME_RE, "must be HH:MM or HH:MM:SS"), z.null()]).describe("HH:MM \u307E\u305F\u306F HH:MM:SS\u3002null \u306A\u3089\u5B9F\u7E3E\u958B\u59CB\u306A\u3057\u3002end_time \u306E\u307F\u6307\u5B9A\u306F\u30A8\u30E9\u30FC"),
+  end_time: z.union([z.string().regex(ACTUAL_TIME_RE, "must be HH:MM or HH:MM:SS"), z.null()]).describe("HH:MM \u307E\u305F\u306F HH:MM:SS\u3002null \u306A\u3089\u672A\u5B8C\u4E86 (running \u6271\u3044)")
+});
+async function setActualTimesHandler(ctx, input) {
+  const existing = await ctx.repos.task.findById(input.id);
+  if (!existing) {
+    throw new McpToolError(`Task not found: ${input.id}`);
+  }
+  const patch = await wrapDomainErrors(
+    () => Promise.resolve(
+      buildSetActualTimesPatch(existing, {
+        startTime: input.start_time,
+        endTime: input.end_time
+      })
+    )
+  );
+  const updated = await ctx.repos.task.update(input.id, patch);
+  return { task: taskSummaryFrom(updated) };
+}
+var skipTaskInputSchema = z.object({
+  id: z.string().uuid({ message: "id must be a UUID" })
+});
+async function skipTaskHandler(ctx, input) {
+  const existing = await ctx.repos.task.findById(input.id);
+  if (!existing) {
+    throw new McpToolError(`Task not found: ${input.id}`);
+  }
+  const updated = await skipTask(ctx.repos.task, input.id);
+  return { task: taskSummaryFrom(updated) };
+}
 var startTaskInputSchema = z.object({
   id: z.string().uuid({ message: "id must be a UUID" })
 });
@@ -2099,6 +3186,332 @@ async function startTaskHandler(ctx, input) {
   const updated = await startTask(ctx.repos.task, input.id);
   return { task: taskSummaryFrom(updated) };
 }
+var updateContextInputSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string().min(1).optional(),
+  description: z.union([z.string(), z.null()]).optional(),
+  icon: z.union([z.string(), z.null()]).optional(),
+  color: z.union([z.string(), z.null()]).optional(),
+  status: z.enum(["active", "archived"]).optional().describe("archived \u5316\u306F archive_context tool \u63A8\u5968")
+});
+async function updateContextHandler(ctx, input) {
+  const existing = await ctx.repos.context.findById(input.id);
+  if (!existing) {
+    throw new McpToolError(`Context not found: ${input.id}`);
+  }
+  const patch = {};
+  if (input.name !== void 0) patch.name = input.name;
+  if (input.description !== void 0) {
+    patch.description = input.description === null ? void 0 : input.description;
+  }
+  if (input.icon !== void 0) {
+    patch.icon = input.icon === null ? void 0 : input.icon;
+  }
+  if (input.color !== void 0) {
+    patch.color = input.color === null ? void 0 : input.color;
+  }
+  if (input.status !== void 0) patch.status = input.status;
+  const updated = await ctx.repos.context.update(input.id, patch);
+  return { context: contextSummaryFrom(updated) };
+}
+var updateProjectInputSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string().min(1).optional(),
+  description: z.union([z.string(), z.null()]).optional(),
+  color: z.union([z.string(), z.null()]).optional(),
+  parent_project_id: z.union([z.string().uuid(), z.null()]).optional(),
+  goal_id: z.union([z.string().uuid(), z.null()]).optional(),
+  started_at: z.union([z.string().datetime(), z.null()]).optional(),
+  target_end_date: z.union([z.string().datetime(), z.null()]).optional(),
+  status: z.enum(["active", "archived"]).optional().describe("archived \u5316\u306F archive_project tool \u63A8\u5968 (\u4E21\u65B9\u3068\u3082 archived_at \u3092\u8A2D\u5B9A\u3059\u308B)")
+});
+async function updateProjectHandler(ctx, input) {
+  const existing = await ctx.repos.project.findById(input.id);
+  if (!existing) {
+    throw new McpToolError(`Project not found: ${input.id}`);
+  }
+  if (input.parent_project_id !== void 0 && input.parent_project_id !== null) {
+    const parent = await ctx.repos.project.findById(input.parent_project_id);
+    if (!parent) {
+      throw new McpToolError(`Parent project not found: ${input.parent_project_id}`);
+    }
+    if (parent.id === input.id) {
+      throw new McpToolError("A project cannot be its own parent");
+    }
+  }
+  const patch = {};
+  if (input.name !== void 0) patch.name = input.name;
+  if (input.description !== void 0) {
+    patch.description = input.description === null ? void 0 : input.description;
+  }
+  if (input.color !== void 0) {
+    patch.color = input.color === null ? void 0 : input.color;
+  }
+  if (input.parent_project_id !== void 0) {
+    patch.parentProjectId = input.parent_project_id === null ? void 0 : input.parent_project_id;
+  }
+  if (input.goal_id !== void 0) {
+    patch.goalId = input.goal_id === null ? void 0 : input.goal_id;
+  }
+  if (input.started_at !== void 0) {
+    patch.startedAt = input.started_at === null ? void 0 : new Date(input.started_at);
+  }
+  if (input.target_end_date !== void 0) {
+    patch.targetEndDate = input.target_end_date === null ? void 0 : new Date(input.target_end_date);
+  }
+  if (input.status !== void 0) patch.status = input.status;
+  const updated = await ctx.repos.project.update(input.id, patch);
+  return { project: projectSummaryFrom(updated) };
+}
+var frequencySchema2 = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("daily") }),
+  z.object({
+    type: z.literal("weekly"),
+    weekdays: z.array(z.number().int().min(0).max(6)).min(1)
+  }),
+  z.object({
+    type: z.literal("monthly"),
+    days: z.array(z.number().int().min(1).max(31)).min(1)
+  }),
+  z.object({ type: z.literal("custom"), cron: z.string().min(1) })
+]);
+var updateRoutineInputSchema = z.object({
+  id: z.string().uuid(),
+  title: z.string().min(1).optional(),
+  description: z.union([z.string(), z.null()]).optional(),
+  estimated_seconds: z.number().int().positive().optional(),
+  frequency: frequencySchema2.optional(),
+  project_id: z.union([z.string().uuid(), z.null()]).optional(),
+  context_id: z.union([z.string().uuid(), z.null()]).optional(),
+  tag_ids: z.array(z.string().uuid()).optional(),
+  default_scheduled_start_time: z.union([z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "must be HH:MM"), z.null()]).optional(),
+  auto_expand: z.boolean().optional(),
+  start_date: z.union([z.string().regex(/^\d{4}-\d{2}-\d{2}$/), z.null()]).optional(),
+  end_date: z.union([z.string().regex(/^\d{4}-\d{2}-\d{2}$/), z.null()]).optional(),
+  status: z.enum(["active", "paused", "archived"]).optional()
+});
+async function updateRoutineHandler(ctx, input) {
+  const existing = await ctx.repos.routine.findById(input.id);
+  if (!existing) {
+    throw new McpToolError(`Routine not found: ${input.id}`);
+  }
+  if (input.project_id !== void 0 && input.project_id !== null) {
+    const p = await ctx.repos.project.findById(input.project_id);
+    if (!p) throw new McpToolError(`Project not found: ${input.project_id}`);
+  }
+  if (input.context_id !== void 0 && input.context_id !== null) {
+    const c = await ctx.repos.context.findById(input.context_id);
+    if (!c) throw new McpToolError(`Context not found: ${input.context_id}`);
+  }
+  if (input.tag_ids !== void 0 && input.tag_ids.length > 0) {
+    const checked = await Promise.all(
+      input.tag_ids.map(async (id) => ({
+        id,
+        exists: await ctx.repos.tag.findById(id) !== null
+      }))
+    );
+    const missing = checked.filter((c) => !c.exists).map((c) => c.id);
+    if (missing.length > 0) throw new McpToolError(`Tag(s) not found: ${missing.join(", ")}`);
+  }
+  const patch = {};
+  if (input.title !== void 0) patch.title = input.title;
+  if (input.description !== void 0) {
+    patch.description = input.description === null ? void 0 : input.description;
+  }
+  if (input.estimated_seconds !== void 0) patch.estimatedSeconds = input.estimated_seconds;
+  if (input.frequency !== void 0) patch.frequency = input.frequency;
+  if (input.project_id !== void 0) {
+    patch.projectId = input.project_id === null ? void 0 : input.project_id;
+  }
+  if (input.context_id !== void 0) {
+    patch.contextId = input.context_id === null ? void 0 : input.context_id;
+  }
+  if (input.tag_ids !== void 0) patch.tagIds = input.tag_ids;
+  if (input.default_scheduled_start_time !== void 0) {
+    patch.defaultScheduledStartTime = input.default_scheduled_start_time === null ? void 0 : input.default_scheduled_start_time;
+  }
+  if (input.auto_expand !== void 0) patch.autoExpand = input.auto_expand;
+  if (input.start_date !== void 0) {
+    patch.startDate = input.start_date === null ? void 0 : input.start_date;
+  }
+  if (input.end_date !== void 0) {
+    patch.endDate = input.end_date === null ? void 0 : input.end_date;
+  }
+  if (input.status !== void 0) patch.status = input.status;
+  const updated = await ctx.repos.routine.update(input.id, patch);
+  const today = todayDateString();
+  const futureTasks = await ctx.repos.task.findByRoutineIdFromDate(input.id, today);
+  const targets = pickPropagationTargets(updated, futureTasks, today);
+  if (targets.length > 0) {
+    const { auditingTask } = ctx.repos;
+    if (!auditingTask) {
+      throw new McpToolError(
+        "auditingTask is not configured. Routine propagation requires audit lookups to be enabled (createNodeAppContext sets this up automatically)."
+      );
+    }
+    const taskPatch = buildRoutineTaskPatch(updated);
+    await Promise.all(
+      targets.map(
+        (task) => auditingTask.updateWithCause(task.id, taskPatch, "routine-propagation")
+      )
+    );
+  }
+  return {
+    routine: routineSummaryFrom(updated),
+    propagated_task_count: targets.length
+  };
+}
+var updateTagInputSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string().min(1).optional(),
+  description: z.union([z.string(), z.null()]).optional(),
+  color: z.union([z.string(), z.null()]).optional(),
+  status: z.enum(["active", "archived"]).optional().describe("archived \u5316\u306F archive_tag tool \u63A8\u5968")
+});
+async function updateTagHandler(ctx, input) {
+  const existing = await ctx.repos.tag.findById(input.id);
+  if (!existing) {
+    throw new McpToolError(`Tag not found: ${input.id}`);
+  }
+  const patch = {};
+  if (input.name !== void 0) patch.name = input.name;
+  if (input.description !== void 0) {
+    patch.description = input.description === null ? void 0 : input.description;
+  }
+  if (input.color !== void 0) {
+    patch.color = input.color === null ? void 0 : input.color;
+  }
+  if (input.status !== void 0) patch.status = input.status;
+  const updated = await ctx.repos.tag.update(input.id, patch);
+  return { tag: tagSummaryFrom(updated) };
+}
+var updateTaskInputSchema = z.object({
+  id: z.string().uuid({ message: "id must be a UUID" }),
+  title: z.string().min(1).optional(),
+  description: z.union([z.string(), z.null()]).optional(),
+  estimated_seconds: z.number().int().positive().optional(),
+  scheduled_start_time: z.union([z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "must be HH:MM"), z.null()]).optional(),
+  project_id: z.union([z.string().uuid(), z.null()]).optional(),
+  context_id: z.union([z.string().uuid(), z.null()]).optional(),
+  tag_ids: z.array(z.string().uuid()).optional(),
+  notify_at_scheduled_start: z.boolean().optional(),
+  is_background: z.boolean().optional()
+});
+async function validateReferences(ctx, refs) {
+  if (refs.projectId) {
+    const project = await ctx.repos.project.findById(refs.projectId);
+    if (!project) throw new McpToolError(`Project not found: ${refs.projectId}`);
+  }
+  if (refs.contextId) {
+    const context = await ctx.repos.context.findById(refs.contextId);
+    if (!context) throw new McpToolError(`Context not found: ${refs.contextId}`);
+  }
+  if (refs.tagIds && refs.tagIds.length > 0) {
+    const checked = await Promise.all(
+      refs.tagIds.map(async (id) => ({ id, exists: await ctx.repos.tag.findById(id) !== null }))
+    );
+    const missing = checked.filter((c) => !c.exists).map((c) => c.id);
+    if (missing.length > 0) {
+      throw new McpToolError(`Tag(s) not found: ${missing.join(", ")}`);
+    }
+  }
+}
+async function updateTaskHandler(ctx, input) {
+  const existing = await ctx.repos.task.findById(input.id);
+  if (!existing) {
+    throw new McpToolError(`Task not found: ${input.id}`);
+  }
+  await validateReferences(ctx, {
+    projectId: input.project_id ?? void 0,
+    contextId: input.context_id ?? void 0,
+    tagIds: input.tag_ids
+  });
+  const patch = {};
+  if (input.title !== void 0) patch.title = input.title;
+  if (input.description !== void 0) {
+    patch.description = input.description === null ? void 0 : input.description;
+  }
+  if (input.estimated_seconds !== void 0) patch.estimatedSeconds = input.estimated_seconds;
+  if (input.scheduled_start_time !== void 0) {
+    patch.scheduledStartTime = input.scheduled_start_time === null ? void 0 : input.scheduled_start_time;
+  }
+  if (input.project_id !== void 0) {
+    patch.projectId = input.project_id === null ? void 0 : input.project_id;
+  }
+  if (input.context_id !== void 0) {
+    patch.contextId = input.context_id === null ? void 0 : input.context_id;
+  }
+  if (input.tag_ids !== void 0) patch.tagIds = input.tag_ids;
+  if (input.notify_at_scheduled_start !== void 0) {
+    patch.notifyAtScheduledStart = input.notify_at_scheduled_start;
+  }
+  if (input.is_background !== void 0) patch.isBackground = input.is_background;
+  const updated = await ctx.repos.task.update(input.id, patch);
+  return { task: taskSummaryFrom(updated) };
+}
+var HHMM2 = /^([01]\d|2[0-3]):[0-5]\d$/;
+var updateTimeBlockInputSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string().min(1).optional(),
+  start_time: z.string().regex(HHMM2, "start_time must be HH:MM").optional(),
+  end_time: z.string().regex(HHMM2, "end_time must be HH:MM").optional(),
+  weekdays: z.array(z.number().int().min(0).max(6)).min(1).optional(),
+  default_project_id: z.union([z.string().uuid(), z.null()]).optional(),
+  default_context_id: z.union([z.string().uuid(), z.null()]).optional(),
+  default_tag_ids: z.array(z.string().uuid()).optional(),
+  color: z.union([z.string(), z.null()]).optional(),
+  start_date: z.union([z.string().regex(/^\d{4}-\d{2}-\d{2}$/), z.null()]).optional(),
+  end_date: z.union([z.string().regex(/^\d{4}-\d{2}-\d{2}$/), z.null()]).optional(),
+  status: z.enum(["active", "archived"]).optional()
+});
+async function updateTimeBlockHandler(ctx, input) {
+  const existing = await ctx.repos.timeBlock.findById(input.id);
+  if (!existing) {
+    throw new McpToolError(`TimeBlock not found: ${input.id}`);
+  }
+  if (input.default_project_id !== void 0 && input.default_project_id !== null) {
+    const p = await ctx.repos.project.findById(input.default_project_id);
+    if (!p) throw new McpToolError(`Project not found: ${input.default_project_id}`);
+  }
+  if (input.default_context_id !== void 0 && input.default_context_id !== null) {
+    const c = await ctx.repos.context.findById(input.default_context_id);
+    if (!c) throw new McpToolError(`Context not found: ${input.default_context_id}`);
+  }
+  if (input.default_tag_ids !== void 0 && input.default_tag_ids.length > 0) {
+    const checked = await Promise.all(
+      input.default_tag_ids.map(async (id) => ({
+        id,
+        exists: await ctx.repos.tag.findById(id) !== null
+      }))
+    );
+    const missing = checked.filter((c) => !c.exists).map((c) => c.id);
+    if (missing.length > 0) throw new McpToolError(`Tag(s) not found: ${missing.join(", ")}`);
+  }
+  const patch = {};
+  if (input.name !== void 0) patch.name = input.name;
+  if (input.start_time !== void 0) patch.startTime = input.start_time;
+  if (input.end_time !== void 0) patch.endTime = input.end_time;
+  if (input.weekdays !== void 0) patch.weekdays = input.weekdays;
+  if (input.default_project_id !== void 0) {
+    patch.defaultProjectId = input.default_project_id === null ? void 0 : input.default_project_id;
+  }
+  if (input.default_context_id !== void 0) {
+    patch.defaultContextId = input.default_context_id === null ? void 0 : input.default_context_id;
+  }
+  if (input.default_tag_ids !== void 0) patch.defaultTagIds = input.default_tag_ids;
+  if (input.color !== void 0) {
+    patch.color = input.color === null ? void 0 : input.color;
+  }
+  if (input.start_date !== void 0) {
+    patch.startDate = input.start_date === null ? void 0 : input.start_date;
+  }
+  if (input.end_date !== void 0) {
+    patch.endDate = input.end_date === null ? void 0 : input.end_date;
+  }
+  if (input.status !== void 0) patch.status = input.status;
+  const updated = await ctx.repos.timeBlock.update(input.id, patch);
+  return { time_block: timeBlockSummaryFrom(updated) };
+}
 
 // src/server.ts
 function createDefaultContextFactory() {
@@ -2144,11 +3557,29 @@ function createMcpServer(opts) {
     "add_task",
     {
       title: "Add task",
-      description: "\u30BF\u30B9\u30AF\u3092\u8FFD\u52A0\u3059\u308B\u3002\u65E5\u4ED8\u7701\u7565\u6642\u306F\u4ECA\u65E5\u3002estimated_seconds \u7701\u7565\u6642\u306F 1800 (30 \u5206)\u3002",
+      description: "\u30BF\u30B9\u30AF\u3092\u8FFD\u52A0\u3059\u308B\u3002\u65E5\u4ED8\u7701\u7565\u6642\u306F\u4ECA\u65E5\u3002estimated_seconds \u7701\u7565\u6642\u306F 1800 (30 \u5206)\u3002project_id / context_id / tag_ids \u306F\u4E8B\u524D\u306B list_projects / list_contexts / list_tags \u3067\u53D6\u5F97\u3057\u305F UUID \u3092\u6E21\u3059\u3002",
       inputSchema: addTaskInputSchema.shape
     },
     async (input) => wrapHandler(ctxFactory, addTaskHandler, input)
   );
+  server.registerTool(
+    "update_task",
+    {
+      title: "Update task",
+      description: "\u30BF\u30B9\u30AF\u306E\u30E6\u30FC\u30B6\u30FC\u7DE8\u96C6\u53EF\u80FD\u30D5\u30A3\u30FC\u30EB\u30C9\u3092\u90E8\u5206\u66F4\u65B0\u3059\u308B\u3002undefined \u306F\u5909\u66F4\u306A\u3057\u3001null \u306F\u660E\u793A\u30AF\u30EA\u30A2\u3002status / order_index / actual_start_time \u7B49\u306E\u30B7\u30B9\u30C6\u30E0\u30D5\u30A3\u30FC\u30EB\u30C9\u306F\u5225 tool (start/pause/done/skip/reopen/reorder) \u7D4C\u7531\u3067\u5909\u66F4\u3059\u308B\u3002tag_ids \u306F\u5168\u7F6E\u63DB\u3002",
+      inputSchema: updateTaskInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, updateTaskHandler, input)
+  );
+  server.registerTool(
+    "delete_task",
+    {
+      title: "Delete task",
+      description: "\u30BF\u30B9\u30AF\u3092\u524A\u9664\u3059\u308B\u3002Routine \u7531\u6765\u30BF\u30B9\u30AF\u3092\u4ECA\u65E5\u4EE5\u964D\u306B\u6D88\u3059\u5834\u5408\u306F routine_expansions \u306B skip \u8A18\u9332\u3059\u308B (default)\u3002hard_delete: true \u306A\u3089\u7269\u7406\u524A\u9664\u306E\u307F\u3067\u3001\u6B21\u306E reload \u3067\u518D\u5C55\u958B\u3055\u308C\u308B (\u4E0A\u7D1A\u8005\u5411\u3051)\u3002",
+      inputSchema: deleteTaskInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, deleteTaskHandler, input)
+  );
   server.registerTool(
     "start_task",
     {
@@ -2176,12 +3607,300 @@ function createMcpServer(opts) {
     },
     async (input) => wrapHandler(ctxFactory, doneTaskHandler, input)
   );
+  server.registerTool(
+    "skip_task",
+    {
+      title: "Skip task",
+      description: "\u30BF\u30B9\u30AF\u3092 skipped \u306B\u9077\u79FB\u3055\u305B\u308B (\u3084\u3089\u306A\u3044\u3053\u3068\u304C\u6C7A\u307E\u3063\u305F\u30BF\u30B9\u30AF\u7528)\u3002reopen_task \u3067 planned \u306B\u623B\u305B\u308B\u3002",
+      inputSchema: skipTaskInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, skipTaskHandler, input)
+  );
+  server.registerTool(
+    "reopen_task",
+    {
+      title: "Reopen task",
+      description: "completed / skipped \u306E\u30BF\u30B9\u30AF\u3092 planned \u306B\u623B\u3059\u3002planned/running/paused \u306E\u3068\u304D\u306F no-op\u3002",
+      inputSchema: reopenTaskInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, reopenTaskHandler, input)
+  );
+  server.registerTool(
+    "list_projects",
+    {
+      title: "List projects",
+      description: "\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u4E00\u89A7\u3092\u8FD4\u3059\u3002`add_task` / `update_task` \u306E `project_id` \u306B\u6E21\u3059 UUID \u3092\u53D6\u5F97\u3059\u308B\u305F\u3081\u306B\u4F7F\u3046\u3002\u65E2\u5B9A\u306F active \u306E\u307F\u3001`status: archived` \u3067 archived \u3082\u53D6\u5F97\u53EF\u80FD\u3002`limit` \u65E2\u5B9A 100\u3002",
+      inputSchema: listProjectsInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, listProjectsHandler, input)
+  );
+  server.registerTool(
+    "list_tags",
+    {
+      title: "List tags",
+      description: "\u30BF\u30B0\u4E00\u89A7\u3092\u8FD4\u3059\u3002`add_task` / `update_task` \u306E `tag_ids` \u306B\u6E21\u3059 UUID \u3092\u53D6\u5F97\u3059\u308B\u305F\u3081\u306B\u4F7F\u3046\u3002`limit` \u65E2\u5B9A 100\u3002",
+      inputSchema: listTagsInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, listTagsHandler, input)
+  );
+  server.registerTool(
+    "list_contexts",
+    {
+      title: "List contexts",
+      description: "\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8 (\u4F5C\u696D\u74B0\u5883\u30BF\u30B0\u3002\u4F8B: home / office / mobile) \u4E00\u89A7\u3092\u8FD4\u3059\u3002`add_task` / `update_task` \u306E `context_id` \u306B\u6E21\u3059 UUID \u3092\u53D6\u5F97\u3059\u308B\u305F\u3081\u306B\u4F7F\u3046\u3002`limit` \u65E2\u5B9A 100\u3002",
+      inputSchema: listContextsInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, listContextsHandler, input)
+  );
+  server.registerTool(
+    "list_routines",
+    {
+      title: "List routines",
+      description: '\u7E70\u308A\u8FD4\u3057\u30BF\u30B9\u30AF\u306E\u30C6\u30F3\u30D7\u30EC\u30FC\u30C8 (\u30EB\u30FC\u30C1\u30F3) \u4E00\u89A7\u3092\u8FD4\u3059\u3002`frequency` \u306F discriminated union (`{type: "daily"}` / `{type: "weekly", weekdays: [1,3,5]}` \u7B49) \u306E\u307E\u307E\u3002`limit` \u65E2\u5B9A 100\u3002',
+      inputSchema: listRoutinesInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, listRoutinesHandler, input)
+  );
+  server.registerTool(
+    "list_time_blocks",
+    {
+      title: "List time blocks",
+      description: "\u30BF\u30A4\u30E0\u30D6\u30ED\u30C3\u30AF (\u6642\u9593\u5E2F\u30C6\u30F3\u30D7\u30EC\u30FC\u30C8\u3002\u4F8B: \u671D\u306E\u96C6\u4E2D\u6642\u9593 09:00-12:00) \u4E00\u89A7\u3092\u8FD4\u3059\u3002`limit` \u65E2\u5B9A 100\u3002",
+      inputSchema: listTimeBlocksInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, listTimeBlocksHandler, input)
+  );
+  server.registerTool(
+    "list_recent_tasks",
+    {
+      title: "List recent tasks",
+      description: "\u904E\u53BB N \u65E5 (\u65E2\u5B9A 90) \u306E\u30BF\u30B9\u30AF\u3092\u8FD4\u3059\u3002`query` \u3092\u6307\u5B9A\u3059\u308B\u3068 fuzzy match \u3067\u985E\u4F3C\u30BF\u30A4\u30C8\u30EB\u4E0A\u4F4D\u3092\u8FD4\u3059 (\u3072\u3089\u304C\u306A\u2194\u30AB\u30BF\u30AB\u30CA\u6B63\u898F\u5316\u8FBC\u307F)\u3002\u300C\u6700\u8FD1\u3084\u3063\u305F\u4F3C\u305F\u30BF\u30B9\u30AF\u3092\u53C2\u8003\u306B\u65B0\u3057\u3044\u30BF\u30B9\u30AF\u3092\u4F5C\u3063\u3066\u300D\u306E\u3088\u3046\u306A AI \u64CD\u4F5C\u5411\u3051\u3002`limit` \u65E2\u5B9A 100\u3002",
+      inputSchema: listRecentTasksInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, listRecentTasksHandler, input)
+  );
+  server.registerTool(
+    "create_project",
+    {
+      title: "Create project",
+      description: "\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u3092\u65B0\u898F\u4F5C\u6210\u3059\u308B\u3002`name` \u5FC5\u9808\u3001`status` \u306F active \u56FA\u5B9A\u3002`parent_project_id` \u3092\u6307\u5B9A\u3059\u308B\u3068\u30B5\u30D6\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u3002",
+      inputSchema: createProjectInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, createProjectHandler, input)
+  );
+  server.registerTool(
+    "update_project",
+    {
+      title: "Update project",
+      description: "\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u3092\u90E8\u5206\u66F4\u65B0\u3059\u308B\u3002undefined=\u5909\u66F4\u306A\u3057\u3001null=\u660E\u793A\u30AF\u30EA\u30A2\u3002`status` \u306E archived \u5316\u306F archive_project tool \u63A8\u5968\u3002\u81EA\u5206\u81EA\u8EAB\u3092 parent \u306B\u3057\u3088\u3046\u3068\u3059\u308B\u3068\u30A8\u30E9\u30FC\u3002",
+      inputSchema: updateProjectInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, updateProjectHandler, input)
+  );
+  server.registerTool(
+    "archive_project",
+    {
+      title: "Archive project",
+      description: "\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u3092\u30A2\u30FC\u30AB\u30A4\u30D6\u3059\u308B (status=archived + archived_at \u30BB\u30C3\u30C8)\u3002\u95A2\u9023\u30BF\u30B9\u30AF\u306E project_id \u306F\u7DAD\u6301\u3055\u308C\u308B\u306E\u3067\u3001\u904E\u53BB\u5C65\u6B74\u304C\u8AAD\u3081\u308B\u3002\u901A\u5E38\u306F delete \u3088\u308A archive \u3092\u63A8\u5968\u3002",
+      inputSchema: archiveProjectInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, archiveProjectHandler, input)
+  );
+  server.registerTool(
+    "delete_project",
+    {
+      title: "Delete project",
+      description: "\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u3092\u7269\u7406\u524A\u9664\u3059\u308B\u3002\u30BF\u30B9\u30AF\u306E project_id \u306F NULL \u5316 (ON DELETE SET NULL)\u3001\u5B50\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u306E parent_project_id \u3082 NULL \u5316\u3002\u904E\u53BB\u5C65\u6B74\u3092\u4FDD\u3061\u305F\u3044\u5834\u5408\u306F archive_project \u3092\u4F7F\u3046\u3002",
+      inputSchema: deleteProjectInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, deleteProjectHandler, input)
+  );
+  server.registerTool(
+    "create_tag",
+    {
+      title: "Create tag",
+      description: "\u30BF\u30B0\u3092\u65B0\u898F\u4F5C\u6210\u3059\u308B\u3002`name` \u5FC5\u9808\u3001status \u306F active \u56FA\u5B9A\u3002",
+      inputSchema: createTagInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, createTagHandler, input)
+  );
+  server.registerTool(
+    "update_tag",
+    {
+      title: "Update tag",
+      description: "\u30BF\u30B0\u3092\u90E8\u5206\u66F4\u65B0\u3059\u308B\u3002null=\u660E\u793A\u30AF\u30EA\u30A2\u3002",
+      inputSchema: updateTagInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, updateTagHandler, input)
+  );
+  server.registerTool(
+    "archive_tag",
+    {
+      title: "Archive tag",
+      description: "\u30BF\u30B0\u3092\u30A2\u30FC\u30AB\u30A4\u30D6\u3059\u308B\u3002\u30BF\u30B9\u30AF\u306E tag_ids \u914D\u5217\u306B id \u306F\u6B8B\u308B\u306E\u3067\u3001\u65E2\u5B58\u30BF\u30B9\u30AF\u306E\u30BF\u30B0\u8868\u793A\u306F\u7DAD\u6301\u3055\u308C\u308B\u3002",
+      inputSchema: archiveTagInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, archiveTagHandler, input)
+  );
+  server.registerTool(
+    "delete_tag",
+    {
+      title: "Delete tag",
+      description: "\u30BF\u30B0\u3092\u7269\u7406\u524A\u9664\u3059\u308B\u3002\u30BF\u30B9\u30AF\u306E tag_ids \u914D\u5217\u306F UUID[] \u5217\u306A\u306E\u3067\u5B64\u5150 id \u304C\u6B8B\u308B (UI \u8868\u793A\u6642\u306B\u300C\u4E0D\u660E\u306A\u30BF\u30B0\u300D\u6271\u3044)\u3002\u5C65\u6B74\u5C0A\u91CD\u306A\u3089 archive_tag \u63A8\u5968\u3002",
+      inputSchema: deleteTagInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, deleteTagHandler, input)
+  );
+  server.registerTool(
+    "create_context",
+    {
+      title: "Create context",
+      description: "\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8 (\u4F5C\u696D\u74B0\u5883\u30BF\u30B0\u3002home / office / mobile \u7B49) \u3092\u65B0\u898F\u4F5C\u6210\u3059\u308B\u3002`name` \u5FC5\u9808\u3001icon \u306F\u7D75\u6587\u5B57\u307E\u305F\u306F\u30A2\u30A4\u30B3\u30F3\u540D\u3002",
+      inputSchema: createContextInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, createContextHandler, input)
+  );
+  server.registerTool(
+    "update_context",
+    {
+      title: "Update context",
+      description: "\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u3092\u90E8\u5206\u66F4\u65B0\u3059\u308B\u3002null=\u660E\u793A\u30AF\u30EA\u30A2\u3002",
+      inputSchema: updateContextInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, updateContextHandler, input)
+  );
+  server.registerTool(
+    "archive_context",
+    {
+      title: "Archive context",
+      description: "\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u3092\u30A2\u30FC\u30AB\u30A4\u30D6\u3059\u308B\u3002\u30BF\u30B9\u30AF\u306E context_id \u306F\u7DAD\u6301\u3002",
+      inputSchema: archiveContextInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, archiveContextHandler, input)
+  );
+  server.registerTool(
+    "delete_context",
+    {
+      title: "Delete context",
+      description: "\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u3092\u7269\u7406\u524A\u9664\u3059\u308B\u3002\u30BF\u30B9\u30AF\u306E context_id \u306F NULL \u5316 (ON DELETE SET NULL)\u3002\u5C65\u6B74\u5C0A\u91CD\u306A\u3089 archive_context \u63A8\u5968\u3002",
+      inputSchema: deleteContextInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, deleteContextHandler, input)
+  );
+  server.registerTool(
+    "create_routine",
+    {
+      title: "Create routine",
+      description: '\u7E70\u308A\u8FD4\u3057\u30BF\u30B9\u30AF\u306E\u30C6\u30F3\u30D7\u30EC\u30FC\u30C8 (\u30EB\u30FC\u30C1\u30F3) \u3092\u65B0\u898F\u4F5C\u6210\u3059\u308B\u3002`frequency` \u306F discriminated union (\u4F8B: {type: "weekly", weekdays: [1,3,5]})\u3002auto_expand=true (default) \u306A\u3089 Today \u3092\u958B\u3044\u305F\u6642\u306B\u81EA\u52D5\u5C55\u958B\u3055\u308C\u308B\u3002',
+      inputSchema: createRoutineInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, createRoutineHandler, input)
+  );
+  server.registerTool(
+    "update_routine",
+    {
+      title: "Update routine (with propagation)",
+      description: "\u30EB\u30FC\u30C1\u30F3\u3092\u90E8\u5206\u66F4\u65B0\u3059\u308B\u3002**\u672A\u6765 (date >= today) \u306E planned \u30BF\u30B9\u30AF\u306B\u81EA\u52D5\u4F1D\u64AD**\u3055\u308C\u308B (title / estimated / project / context / tags / scheduled_start_time)\u3002\u624B\u52D5\u7DE8\u96C6\u3057\u3066\u3044\u305F\u30BF\u30B9\u30AF\u306E\u8A72\u5F53\u30D5\u30A3\u30FC\u30EB\u30C9\u3082\u4E0A\u66F8\u304D\u3055\u308C\u308B\u70B9\u306B\u6CE8\u610F\u3002\u5B9F\u884C\u4E2D\u30FB\u5B8C\u4E86\u30FB\u30B9\u30AD\u30C3\u30D7\u6E08\u307F\u30FB\u904E\u53BB\u65E5\u306E\u30BF\u30B9\u30AF\u306F\u4FDD\u8B77\u3055\u308C\u308B\u3002propagated_task_count \u3092\u8FD4\u3059\u3002",
+      inputSchema: updateRoutineInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, updateRoutineHandler, input)
+  );
+  server.registerTool(
+    "archive_routine",
+    {
+      title: "Archive routine",
+      description: "\u30EB\u30FC\u30C1\u30F3\u3092\u30A2\u30FC\u30AB\u30A4\u30D6\u3059\u308B (status=archived)\u3002\u65E2\u5B58\u30BF\u30B9\u30AF\u306E routine_id \u306F\u7DAD\u6301\u3055\u308C\u308B (\u5C65\u6B74\u53EF)\u3002\u65B0\u898F\u5C55\u958B\u306F\u6B62\u307E\u308B\u3002",
+      inputSchema: archiveRoutineInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, archiveRoutineHandler, input)
+  );
+  server.registerTool(
+    "delete_routine",
+    {
+      title: "Delete routine",
+      description: "\u30EB\u30FC\u30C1\u30F3\u3092\u7269\u7406\u524A\u9664\u3059\u308B\u3002\u30BF\u30B9\u30AF\u306E routine_id \u306F ON DELETE SET NULL \u3067 NULL \u5316 (\u300Croutine \u7531\u6765\u300D\u306E\u30E9\u30D9\u30EB\u304C\u5931\u308F\u308C\u308B)\u3002\u5C65\u6B74\u5C0A\u91CD\u306A\u3089 archive_routine \u63A8\u5968\u3002",
+      inputSchema: deleteRoutineInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, deleteRoutineHandler, input)
+  );
+  server.registerTool(
+    "create_time_block",
+    {
+      title: "Create time block",
+      description: "\u30BF\u30A4\u30E0\u30D6\u30ED\u30C3\u30AF (\u6642\u9593\u5E2F\u30C6\u30F3\u30D7\u30EC\u30FC\u30C8) \u3092\u65B0\u898F\u4F5C\u6210\u3059\u308B\u3002weekdays \u306F 0=\u65E5\u66DC\uFF5E6=\u571F\u66DC\u306E\u914D\u5217 (\u7A7A\u914D\u5217\u4E0D\u53EF)\u3002default_project_id / default_context_id / default_tag_ids \u3092\u6307\u5B9A\u3059\u308B\u3068\u30D6\u30ED\u30C3\u30AF\u7BC4\u56F2\u306B\u8FFD\u52A0\u3055\u308C\u305F\u30BF\u30B9\u30AF\u306E\u30C7\u30D5\u30A9\u30EB\u30C8\u306B\u4F7F\u308F\u308C\u308B\u3002",
+      inputSchema: createTimeBlockInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, createTimeBlockHandler, input)
+  );
+  server.registerTool(
+    "update_time_block",
+    {
+      title: "Update time block",
+      description: "\u30BF\u30A4\u30E0\u30D6\u30ED\u30C3\u30AF\u3092\u90E8\u5206\u66F4\u65B0\u3059\u308B\u3002default_tag_ids \u306F\u914D\u5217\u6307\u5B9A\u3067\u5168\u7F6E\u63DB\u3001null \u30AF\u30EA\u30A2\u306F default_project_id / default_context_id / color / start_date / end_date \u306E\u307F\u5BFE\u5FDC\u3002",
+      inputSchema: updateTimeBlockInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, updateTimeBlockHandler, input)
+  );
+  server.registerTool(
+    "archive_time_block",
+    {
+      title: "Archive time block",
+      description: "\u30BF\u30A4\u30E0\u30D6\u30ED\u30C3\u30AF\u3092\u30A2\u30FC\u30AB\u30A4\u30D6\u3059\u308B (status=archived)\u3002\u904E\u53BB\u65E5\u8868\u793A\u3067\u306F\u5F53\u6642\u306E\u72B6\u614B\u304C\u518D\u73FE\u3055\u308C\u308B\u3002",
+      inputSchema: archiveTimeBlockInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, archiveTimeBlockHandler, input)
+  );
+  server.registerTool(
+    "delete_time_block",
+    {
+      title: "Delete time block",
+      description: "\u30BF\u30A4\u30E0\u30D6\u30ED\u30C3\u30AF\u3092\u7269\u7406\u524A\u9664\u3059\u308B\u3002\u30BF\u30B9\u30AF\u306F\u6642\u523B\u30D9\u30FC\u30B9\u3067\u52D5\u7684\u306B\u30D6\u30ED\u30C3\u30AF\u3092\u5224\u5B9A\u3059\u308B\u306E\u3067\u53C2\u7167\u4E0D\u6574\u5408\u306F\u767A\u751F\u3057\u306A\u3044\u304C\u3001\u904E\u53BB\u65E5\u8868\u793A\u3067\u3082\u3053\u306E\u30D6\u30ED\u30C3\u30AF\u306F\u51FA\u3066\u3053\u306A\u304F\u306A\u308B\u3002",
+      inputSchema: deleteTimeBlockInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, deleteTimeBlockHandler, input)
+  );
+  server.registerTool(
+    "set_actual_times",
+    {
+      title: "Set actual start/end times",
+      description: "\u5B9F\u7E3E\u958B\u59CB/\u7D42\u4E86\u6642\u523B\u3092\u76F4\u63A5\u6307\u5B9A\u3059\u308B (Play \u62BC\u3057\u5FD8\u308C\u30EA\u30AB\u30D0\u30EA\u7528)\u3002start+end \u2192 completed\u3001start \u306E\u307F \u2192 running\u3001\u4E21\u65B9 null \u2192 planned \u30EA\u30BB\u30C3\u30C8\u3002end < start \u306A\u3089\u65E5\u8DE8\u304E\u30BB\u30C3\u30B7\u30E7\u30F3\u6271\u3044 (Domain \u3067 finishedAt \u3092\u7FCC\u65E5\u7E70\u4E0A\u3052)\u3002",
+      inputSchema: setActualTimesInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, setActualTimesHandler, input)
+  );
+  server.registerTool(
+    "interrupt_task",
+    {
+      title: "Interrupt running task",
+      description: "\u8D70\u884C\u4E2D\u30BF\u30B9\u30AF\u3092\u300C\u5272\u308A\u8FBC\u307F\u300D\u3067\u5206\u5272\u3059\u308B\u30021 \u547C\u3073\u51FA\u3057\u3067 3 \u30BF\u30B9\u30AF\u3092\u64CD\u4F5C: (1) \u5143\u30BF\u30B9\u30AF\u3092 completed (\u5B9F\u7E3E\u306F\u305D\u3053\u307E\u3067)\u3001(2) \u5272\u308A\u8FBC\u307F\u30BF\u30B9\u30AF\u3092 running \u3067\u65B0\u898F\u4F5C\u6210 (\u5373\u8A08\u6E2C\u958B\u59CB)\u3001(3) \u5143\u30BF\u30B9\u30AF\u306E\u6B8B\u4F5C\u696D\u3092 planned \u3067\u65B0\u898F\u4F5C\u6210 (splitFromTaskId \u3067\u30EA\u30CD\u30FC\u30B8\u4FDD\u6301)\u3002split note 3 \u4EF6\u304C\u81EA\u52D5\u8A18\u9332\u3055\u308C\u308B\u3002\u5BFE\u8C61\u30BF\u30B9\u30AF\u304C running \u4E2D\u3067\u306A\u3044\u3068\u30A8\u30E9\u30FC\u3002",
+      inputSchema: interruptTaskInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, interruptTaskHandler, input)
+  );
+  server.registerTool(
+    "add_parallel_task",
+    {
+      title: "Add parallel task",
+      description: "\u9032\u884C\u4E2D\u30BF\u30B9\u30AF\u3068\u4E26\u884C\u3059\u308B\u65B0\u898F\u30BF\u30B9\u30AF\u3092\u8FFD\u52A0\u3059\u308B\u3002start_immediately: true (default) \u3067 running \u72B6\u614B + \u5373\u8A08\u6E2C\u958B\u59CB\u3002false \u3067 planned \u4F5C\u6210\u306E\u307F\u3002is_background: true \u4F75\u7528\u3067\u898B\u7A4D\u3082\u308A\u96C6\u8A08\u304B\u3089\u9664\u5916\u3002",
+      inputSchema: addParallelTaskInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, addParallelTaskHandler, input)
+  );
+  server.registerTool(
+    "reorder_task",
+    {
+      title: "Reorder task",
+      description: "\u30BF\u30B9\u30AF\u306E\u4E26\u3073\u9806 (order_index) \u3092\u5909\u66F4\u3059\u308B\u3002\u6163\u7FD2\u3067 10 \u5358\u4F4D (\u96A3\u63A5\u4E2D\u9593\u633F\u5165\u306F 5 \u3084 15)\u3002scheduled_start_time \u3082\u540C\u6642\u6307\u5B9A\u53EF\u80FD (null=\u672A\u5272\u5F53\u30B0\u30EB\u30FC\u30D7\u3078\u3001HH:MM=\u8A72\u5F53\u30BF\u30A4\u30E0\u30D6\u30ED\u30C3\u30AF\u3078\u79FB\u52D5)\u3002",
+      inputSchema: reorderTaskInputSchema.shape
+    },
+    async (input) => wrapHandler(ctxFactory, reorderTaskHandler, input)
+  );
   return server;
 }
 
 // src/index.ts
 async function main() {
-  const version = "0.1.2" ;
+  const version = "0.3.0" ;
   const server = createMcpServer({ version });
   const transport = new StdioServerTransport();
   await server.connect(transport);