@vheins/local-memory-mcp 0.8.42 → 0.8.44

package/dist/{chunk-JWJOO5N5.js → chunk-RHTFBGAQ.js}

@@ -3,8 +3,8 @@ import { fileURLToPath } from "url";
 import path from "path";
 var __dirname = path.dirname(fileURLToPath(import.meta.url));
 var pkgVersion = "0.1.0";
-if ("0.8.42") {
-  pkgVersion = "0.8.42";
+if ("0.8.44") {
+  pkgVersion = "0.8.44";
 } else {
   let searchDir = __dirname;
   for (let i = 0; i < 5; i++) {
@@ -305,6 +305,28 @@ var MigrationManager = class {
       CREATE INDEX IF NOT EXISTS idx_task_comments_repo ON task_comments(repo);
       CREATE INDEX IF NOT EXISTS idx_task_comments_created_at ON task_comments(created_at DESC);
 
+      CREATE TABLE IF NOT EXISTS coding_standards (
+        id TEXT PRIMARY KEY,
+        title TEXT NOT NULL,
+        content TEXT NOT NULL,
+        context TEXT,
+        version TEXT,
+        language TEXT,
+        stack TEXT,
+        is_global INTEGER NOT NULL DEFAULT 0,
+        repo TEXT,
+        tags TEXT,
+        metadata TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        agent TEXT NOT NULL DEFAULT 'unknown',
+        model TEXT NOT NULL DEFAULT 'unknown'
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_coding_standards_repo ON coding_standards(repo);
+      CREATE INDEX IF NOT EXISTS idx_coding_standards_is_global ON coding_standards(is_global);
+      CREATE INDEX IF NOT EXISTS idx_coding_standards_language ON coding_standards(language);
+
       CREATE TABLE IF NOT EXISTS memories_archive (
         id TEXT PRIMARY KEY,
         repo TEXT NOT NULL,
@@ -340,6 +362,45 @@ var MigrationManager = class {
 
       CREATE INDEX IF NOT EXISTS idx_action_log_repo ON action_log(repo);
       CREATE INDEX IF NOT EXISTS idx_action_log_created_at ON action_log(created_at);
+
+      CREATE TABLE IF NOT EXISTS handoffs (
+        id TEXT PRIMARY KEY,
+        repo TEXT NOT NULL,
+        from_agent TEXT NOT NULL,
+        to_agent TEXT,
+        task_id TEXT,
+        summary TEXT NOT NULL,
+        context TEXT NOT NULL DEFAULT '{}',
+        status TEXT NOT NULL DEFAULT 'pending',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        expires_at TEXT,
+        FOREIGN KEY (task_id) REFERENCES tasks(id) ON DELETE SET NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_handoffs_repo ON handoffs(repo);
+      CREATE INDEX IF NOT EXISTS idx_handoffs_status ON handoffs(status);
+      CREATE INDEX IF NOT EXISTS idx_handoffs_from_agent ON handoffs(from_agent);
+      CREATE INDEX IF NOT EXISTS idx_handoffs_to_agent ON handoffs(to_agent);
+      CREATE INDEX IF NOT EXISTS idx_handoffs_task_id ON handoffs(task_id);
+      CREATE INDEX IF NOT EXISTS idx_handoffs_created_at ON handoffs(created_at);
+
+      CREATE TABLE IF NOT EXISTS claims (
+        id TEXT PRIMARY KEY,
+        repo TEXT NOT NULL,
+        task_id TEXT NOT NULL,
+        agent TEXT NOT NULL,
+        role TEXT NOT NULL DEFAULT 'unknown',
+        claimed_at TEXT NOT NULL,
+        released_at TEXT,
+        metadata TEXT NOT NULL DEFAULT '{}',
+        FOREIGN KEY (task_id) REFERENCES tasks(id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_claims_repo ON claims(repo);
+      CREATE INDEX IF NOT EXISTS idx_claims_task_id ON claims(task_id);
+      CREATE INDEX IF NOT EXISTS idx_claims_agent ON claims(agent);
+      CREATE INDEX IF NOT EXISTS idx_claims_claimed_at ON claims(claimed_at);
     `);
     const columnsToAdd = [
       { name: "title", table: "memories", definition: "ALTER TABLE memories ADD COLUMN title TEXT" },
@@ -2021,6 +2082,272 @@ var SummaryEntity = class extends BaseEntity {
   }
 };
 
+// src/mcp/entities/standard.ts
+var StandardEntity = class extends BaseEntity {
+  insert(entry) {
+    this.run(
+      `INSERT INTO coding_standards (
+				id, title, content, context, version, language, stack,
+				is_global, repo, tags, metadata, created_at, updated_at, agent, model
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        entry.id,
+        entry.title,
+        entry.content,
+        entry.context,
+        entry.version,
+        entry.language ?? null,
+        entry.stack.length > 0 ? JSON.stringify(entry.stack) : null,
+        entry.is_global ? 1 : 0,
+        entry.repo ?? null,
+        entry.tags.length > 0 ? JSON.stringify(entry.tags) : null,
+        Object.keys(entry.metadata).length > 0 ? JSON.stringify(entry.metadata) : null,
+        entry.created_at,
+        entry.updated_at,
+        entry.agent,
+        entry.model
+      ]
+    );
+  }
+  getById(id) {
+    const row = this.get("SELECT * FROM coding_standards WHERE id = ?", [id]);
+    return row ? this.rowToEntry(row) : null;
+  }
+  search(options) {
+    const { query, context, language, stack, repo, is_global, limit = 20, offset = 0 } = options;
+    const where = [];
+    const params = [];
+    if (query) {
+      where.push("(title LIKE ? OR content LIKE ? OR context LIKE ?)");
+      params.push(`%${query}%`, `%${query}%`, `%${query}%`);
+    }
+    if (context) {
+      where.push("context = ?");
+      params.push(context);
+    }
+    if (language) {
+      where.push("language = ?");
+      params.push(language);
+    }
+    if (stack) {
+      where.push("stack LIKE ?");
+      params.push(`%${stack}%`);
+    }
+    if (repo !== void 0) {
+      where.push("(repo = ? OR is_global = 1)");
+      params.push(repo);
+    }
+    if (is_global !== void 0) {
+      where.push("is_global = ?");
+      params.push(is_global ? 1 : 0);
+    }
+    const whereClause = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
+    const sql = `SELECT * FROM coding_standards ${whereClause} ORDER BY created_at DESC LIMIT ? OFFSET ?`;
+    params.push(limit, offset);
+    const rows = this.all(sql, params);
+    return rows.map((r) => this.rowToEntry(r));
+  }
+  update(id, updates) {
+    const fields = [];
+    const values = [];
+    Object.keys(updates).forEach((key) => {
+      const k = key;
+      const val = updates[k];
+      if (val !== void 0) {
+        if (k === "stack" || k === "tags") {
+          fields.push(`${k} = ?`);
+          values.push(Array.isArray(val) ? JSON.stringify(val) : val);
+        } else if (k === "metadata") {
+          fields.push(`${k} = ?`);
+          values.push(typeof val === "object" ? JSON.stringify(val) : val);
+        } else if (k === "is_global") {
+          fields.push(`${k} = ?`);
+          values.push(val ? 1 : 0);
+        } else if (k !== "id" && k !== "created_at") {
+          fields.push(`${k} = ?`);
+          values.push(val);
+        }
+      }
+    });
+    if (fields.length === 0) return;
+    fields.push("updated_at = ?");
+    values.push((/* @__PURE__ */ new Date()).toISOString());
+    values.push(id);
+    this.run(`UPDATE coding_standards SET ${fields.join(", ")} WHERE id = ?`, values);
+  }
+  delete(id) {
+    this.run("DELETE FROM coding_standards WHERE id = ?", [id]);
+  }
+  rowToEntry(row) {
+    return {
+      id: row.id,
+      title: row.title,
+      content: row.content,
+      context: row.context,
+      version: row.version,
+      language: row.language ?? null,
+      stack: this.safeJSONParse(row.stack, []),
+      is_global: row.is_global === 1,
+      repo: row.repo ?? null,
+      tags: this.safeJSONParse(row.tags, []),
+      metadata: this.safeJSONParse(row.metadata, {}),
+      created_at: row.created_at,
+      updated_at: row.updated_at,
+      agent: row.agent,
+      model: row.model
+    };
+  }
+};
+
+// src/mcp/entities/handoff.ts
+import { randomUUID } from "crypto";
+var HandoffEntity = class extends BaseEntity {
+  rowToHandoff(row) {
+    return {
+      id: row.id,
+      repo: row.repo,
+      from_agent: row.from_agent,
+      to_agent: row.to_agent ?? null,
+      task_id: row.task_id ?? null,
+      summary: row.summary,
+      context: this.safeJSONParse(row.context, {}),
+      status: row.status,
+      created_at: row.created_at,
+      updated_at: row.updated_at,
+      expires_at: row.expires_at ?? null
+    };
+  }
+  rowToClaim(row) {
+    return {
+      id: row.id,
+      repo: row.repo,
+      task_id: row.task_id,
+      agent: row.agent,
+      role: row.role,
+      claimed_at: row.claimed_at,
+      released_at: row.released_at ?? null,
+      metadata: this.safeJSONParse(row.metadata, {})
+    };
+  }
+  createHandoff(params) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const id = randomUUID();
+    this.run(
+      `INSERT INTO handoffs (id, repo, from_agent, to_agent, task_id, summary, context, status, created_at, updated_at, expires_at)
+			VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        id,
+        params.repo,
+        params.from_agent,
+        params.to_agent ?? null,
+        params.task_id ?? null,
+        params.summary,
+        JSON.stringify(params.context ?? {}),
+        "pending",
+        now,
+        now,
+        params.expires_at ?? null
+      ]
+    );
+    return this.rowToHandoff(this.get("SELECT * FROM handoffs WHERE id = ?", [id]));
+  }
+  listHandoffs(params) {
+    const conditions = ["repo = ?"];
+    const values = [params.repo];
+    if (params.status) {
+      conditions.push("status = ?");
+      values.push(params.status);
+    }
+    if (params.to_agent) {
+      conditions.push("to_agent = ?");
+      values.push(params.to_agent);
+    }
+    if (params.from_agent) {
+      conditions.push("from_agent = ?");
+      values.push(params.from_agent);
+    }
+    const limit = params.limit ?? 50;
+    const offset = params.offset ?? 0;
+    values.push(limit, offset);
+    const rows = this.all(
+      `SELECT * FROM handoffs WHERE ${conditions.join(" AND ")} ORDER BY created_at DESC LIMIT ? OFFSET ?`,
+      values
+    );
+    return rows.map((r) => this.rowToHandoff(r));
+  }
+  getHandoffById(id) {
+    const row = this.get("SELECT * FROM handoffs WHERE id = ?", [id]);
+    return row ? this.rowToHandoff(row) : null;
+  }
+  updateHandoffStatus(id, status) {
+    const result = this.run("UPDATE handoffs SET status = ?, updated_at = ? WHERE id = ?", [
+      status,
+      (/* @__PURE__ */ new Date()).toISOString(),
+      id
+    ]);
+    return result.changes > 0;
+  }
+  claimTask(params) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const id = randomUUID();
+    this.run(
+      "UPDATE claims SET released_at = ? WHERE task_id = ? AND released_at IS NULL",
+      [now, params.task_id]
+    );
+    this.run(
+      `INSERT INTO claims (id, repo, task_id, agent, role, claimed_at, released_at, metadata)
+			VALUES (?, ?, ?, ?, ?, ?, NULL, ?)`,
+      [
+        id,
+        params.repo,
+        params.task_id,
+        params.agent,
+        params.role ?? "unknown",
+        now,
+        JSON.stringify(params.metadata ?? {})
+      ]
+    );
+    return this.rowToClaim(this.get("SELECT * FROM claims WHERE id = ?", [id]));
+  }
+  getClaim(task_id) {
+    const row = this.get(
+      "SELECT * FROM claims WHERE task_id = ? AND released_at IS NULL ORDER BY claimed_at DESC LIMIT 1",
+      [task_id]
+    );
+    return row ? this.rowToClaim(row) : null;
+  }
+  releaseClaim(task_id, agent) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    let sql = "UPDATE claims SET released_at = ? WHERE task_id = ? AND released_at IS NULL";
+    const params = [now, task_id];
+    if (agent) {
+      sql += " AND agent = ?";
+      params.push(agent);
+    }
+    const result = this.run(sql, params);
+    return result.changes > 0;
+  }
+  listClaims(params) {
+    const conditions = ["repo = ?"];
+    const values = [params.repo];
+    if (params.agent) {
+      conditions.push("agent = ?");
+      values.push(params.agent);
+    }
+    if (params.active_only) {
+      conditions.push("released_at IS NULL");
+    }
+    const limit = params.limit ?? 50;
+    const offset = params.offset ?? 0;
+    values.push(limit, offset);
+    const rows = this.all(
+      `SELECT * FROM claims WHERE ${conditions.join(" AND ")} ORDER BY claimed_at DESC LIMIT ? OFFSET ?`,
+      values
+    );
+    return rows.map((r) => this.rowToClaim(r));
+  }
+};
+
 // src/mcp/storage/write-lock.ts
 import lockfile from "proper-lockfile";
 import path2 from "path";
@@ -2104,6 +2431,8 @@ var SQLiteStore = class _SQLiteStore {
   actions;
   system;
   summaries;
+  standards;
+  handoffs;
   lock;
   dbPathInstance;
   constructor(dbPath) {
@@ -2132,6 +2461,8 @@ var SQLiteStore = class _SQLiteStore {
     this.actions = new ActionEntity(this.db);
     this.system = new SystemEntity(this.db);
     this.summaries = new SummaryEntity(this.db);
+    this.standards = new StandardEntity(this.db);
+    this.handoffs = new HandoffEntity(this.db);
     this.lock = new WriteLock(finalPath);
   }
   /**
@@ -2347,8 +2678,6 @@ var MemoryTypeSchema = z.enum([
   "decision",
   "mistake",
   "pattern",
-  "agent_handoff",
-  "agent_registered",
   "file_claim",
   "task_archive"
 ]);
@@ -2555,6 +2884,68 @@ var TaskGetSchema = z.object({
 }).refine((data) => data.id !== void 0 || data.task_code !== void 0, {
   message: "Either id or task_code must be provided"
 });
+var HandoffStatusSchema = z.enum(["pending", "accepted", "rejected", "expired"]);
+var HandoffCreateSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  from_agent: z.string().min(1),
+  to_agent: z.string().min(1).optional(),
+  task_id: z.string().uuid().optional(),
+  task_code: z.string().optional(),
+  summary: z.string().min(1),
+  context: z.record(z.string(), z.any()).optional(),
+  expires_at: z.string().optional(),
+  structured: z.boolean().default(false)
+}).refine((data) => !(data.task_id && data.task_code), {
+  message: "Provide either task_id or task_code, not both"
+});
+var HandoffListSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  status: HandoffStatusSchema.optional(),
+  from_agent: z.string().min(1).optional(),
+  to_agent: z.string().min(1).optional(),
+  limit: z.number().min(1).max(100).default(20),
+  offset: z.number().min(0).default(0),
+  structured: z.boolean().default(false)
+});
+var TaskClaimSchema = z.object({
+  repo: z.string().min(1).transform(normalizeRepo),
+  task_id: z.string().uuid().optional(),
+  task_code: z.string().optional(),
+  agent: z.string().min(1),
+  role: z.string().optional(),
+  metadata: z.record(z.string(), z.any()).optional(),
+  structured: z.boolean().default(false)
+}).refine((data) => data.task_id !== void 0 || data.task_code !== void 0, {
+  message: "Either task_id or task_code must be provided"
+}).refine((data) => !(data.task_id && data.task_code), {
+  message: "Provide either task_id or task_code, not both"
+});
+var StandardStoreSchema = z.object({
+  name: z.string().min(3).max(255),
+  content: z.string().min(10),
+  context: z.string().optional(),
+  version: z.string().optional(),
+  language: z.string().optional(),
+  stack: z.array(z.string()).optional(),
+  repo: z.string().optional(),
+  is_global: z.boolean().optional(),
+  tags: z.array(z.string()).optional(),
+  metadata: z.record(z.string(), z.any()).optional(),
+  agent: z.string().optional(),
+  model: z.string().optional(),
+  structured: z.boolean().default(false)
+});
+var StandardSearchSchema = z.object({
+  query: z.string().optional(),
+  stack: z.array(z.string()).optional(),
+  language: z.string().optional(),
+  version: z.string().optional(),
+  repo: z.string().optional(),
+  is_global: z.boolean().optional(),
+  limit: z.number().min(1).max(100).default(20),
+  offset: z.number().min(0).default(0),
+  structured: z.boolean().default(false)
+});
 var TOOL_DEFINITIONS = [
   {
     name: "memory-synthesize",
@@ -2649,14 +3040,14 @@ var TOOL_DEFINITIONS = [
   {
     name: "memory-detail",
     title: "Memory Detail",
-    description: "Fetch full details of a specific memory by ID. Use this when you have a memory ID (e.g. from search results) and need to read the full content.",
+    description: "Fetch full details of a specific memory by ID or short code. Use after memory-recap or memory-search when a pointer row is relevant and full content is needed.",
     inputSchema: {
       type: "object",
       properties: {
-        id: { type: "string", format: "uuid", description: "Memory entry ID" },
+        id: { type: "string", format: "uuid", description: "Memory entry ID. Optional if code is provided." },
+        code: { type: "string", description: "Short memory code. Optional if id is provided." },
         structured: { type: "boolean", default: false, description: "If true, returns structured JSON details." }
-      },
-      required: ["id"]
+      }
     }
   },
   {
@@ -2698,8 +3089,6 @@ var TOOL_DEFINITIONS = [
             "decision",
             "mistake",
             "pattern",
-            "agent_handoff",
-            "agent_registered",
             "file_claim",
             "task_archive"
           ],
@@ -2828,8 +3217,6 @@ var TOOL_DEFINITIONS = [
             "decision",
             "mistake",
             "pattern",
-            "agent_handoff",
-            "agent_registered",
             "file_claim",
             "task_archive"
           ]
@@ -2892,8 +3279,6 @@ var TOOL_DEFINITIONS = [
               "decision",
               "mistake",
               "pattern",
-              "agent_handoff",
-              "agent_registered",
               "file_claim",
               "task_archive"
             ]
@@ -3024,7 +3409,7 @@ var TOOL_DEFINITIONS = [
   {
     name: "memory-recap",
     title: "Memory Recap",
-    description: "AGGREGATED OVERVIEW LAYER: Returns stats (counts by type) and a pointer table of top memories [id, title, type, importance]. NO content. Use for orientation only \u2014 retrieve full memory via memory-detail.",
+    description: "AGGREGATED OVERVIEW LAYER: Returns stats (counts by type) and a pointer table of top memories [id, code, title, type, importance]. NO content. Use for orientation only \u2014 retrieve full memory via memory-detail.",
     annotations: {
       readOnlyHint: true,
       idempotentHint: true,
@@ -3067,12 +3452,12 @@ var TOOL_DEFINITIONS = [
         stats: {
           type: "object",
           properties: {
-            by_type: {
+            byType: {
               type: "object",
               description: "Count of active memories per type (e.g. { decision: 3, code_fact: 7 })"
             }
           },
-          required: ["by_type"]
+          required: ["byType"]
         },
         top: {
           type: "object",
@@ -3080,12 +3465,12 @@ var TOOL_DEFINITIONS = [
             columns: {
               type: "array",
               items: { type: "string" },
-              description: "Column names: [id, title, type, importance]"
+              description: "Column names: [id, code, title, type, importance]"
             },
             rows: {
               type: "array",
               items: { type: "array" },
-              description: "Each row: [id, title, type, importance]. Fetch full content via memory-detail"
+              description: "Each row: [id, code, title, type, importance]. Fetch full content via memory-detail"
             }
           },
           required: ["columns", "rows"]
@@ -3279,7 +3664,7 @@ var TOOL_DEFINITIONS = [
   {
     name: "task-list",
     title: "Task List",
-    description: "PRIMARY navigation and search tool for tasks. Returns a compact tabular list of tasks (id, task_code, title, status, priority, updated_at). Defaults to in_progress and pending tasks. Use 'query' to filter by code, title, or description. Use 'status' (comma-separated) for specific filters. AGENTS: call this once at start, pick ONE task, then call task-detail.",
+    description: "PRIMARY navigation and search tool for tasks. Returns a compact tabular list of tasks (id, task_code, title, status, priority, updated_at, comments_count). Defaults to in_progress and pending tasks. Use 'query' to filter by code, title, or description. Use 'status' (comma-separated) for specific filters. AGENTS: call this once at start, pick ONE task, then call task-detail.",
     annotations: {
       readOnlyHint: true,
       idempotentHint: true,
@@ -3351,6 +3736,285 @@ var TOOL_DEFINITIONS = [
       },
       required: ["schema", "tasks", "count"]
     }
+  },
+  {
+    name: "handoff-create",
+    title: "Handoff Create",
+    description: "Create a handoff record when work needs context transfer between agents. Optionally link it to a task by task_id or task_code, and put machine-readable details in context.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: false,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "Repository name" },
+        from_agent: { type: "string", description: "Agent creating the handoff" },
+        to_agent: { type: "string", description: "Optional target agent" },
+        task_id: { type: "string", format: "uuid", description: "Optional task id to associate" },
+        task_code: { type: "string", description: "Optional task code to associate" },
+        summary: { type: "string", minLength: 1, description: "Concise human-readable transfer summary" },
+        context: {
+          type: "object",
+          description: "Structured handoff context, such as changed files, blockers, verification status, and next steps"
+        },
+        expires_at: { type: "string", description: "Optional expiration timestamp" },
+        structured: { type: "boolean", default: false }
+      },
+      required: ["repo", "from_agent", "summary"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string" },
+        repo: { type: "string" },
+        from_agent: { type: "string" },
+        to_agent: { type: "string", nullable: true },
+        task_id: { type: "string", nullable: true },
+        summary: { type: "string" },
+        context: { type: "object" },
+        status: { type: "string", enum: ["pending", "accepted", "rejected", "expired"] },
+        created_at: { type: "string" },
+        updated_at: { type: "string" },
+        expires_at: { type: "string", nullable: true }
+      },
+      required: ["id", "repo", "from_agent", "summary", "context", "status", "created_at", "updated_at"]
+    }
+  },
+  {
+    name: "handoff-list",
+    title: "Handoff List",
+    description: "Navigation layer for handoff queues. List repository handoffs with optional status and agent filters, then inspect selected rows before acting.",
+    annotations: {
+      readOnlyHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "Repository name" },
+        status: { type: "string", enum: ["pending", "accepted", "rejected", "expired"] },
+        from_agent: { type: "string" },
+        to_agent: { type: "string" },
+        limit: { type: "number", minimum: 1, maximum: 100, default: 20 },
+        offset: { type: "number", minimum: 0, default: 0 },
+        structured: { type: "boolean", default: false }
+      },
+      required: ["repo"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        schema: { type: "string", enum: ["handoff-list"] },
+        handoffs: {
+          type: "object",
+          properties: {
+            columns: {
+              type: "array",
+              items: { type: "string" },
+              description: "Column names: [id, from_agent, to_agent, task_id, status, created_at, summary]"
+            },
+            rows: {
+              type: "array",
+              items: { type: "array" },
+              description: "Each row: [id, from_agent, to_agent, task_id, status, created_at, summary]"
+            }
+          },
+          required: ["columns", "rows"]
+        },
+        count: { type: "number" },
+        offset: { type: "number" }
+      },
+      required: ["schema", "handoffs", "count", "offset"]
+    }
+  },
+  {
+    name: "task-claim",
+    title: "Task Claim",
+    description: "Claim task ownership for an agent using the dedicated claims table. Use this before taking work from task-list; provide either task_id or task_code.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: false,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "Repository name" },
+        task_id: { type: "string", format: "uuid", description: "Task id to claim. Optional if task_code is provided." },
+        task_code: { type: "string", description: "Task code to claim. Optional if task_id is provided." },
+        agent: { type: "string", description: "Claiming agent name" },
+        role: { type: "string", description: "Claiming agent role" },
+        metadata: { type: "object", description: "Optional claim metadata" },
+        structured: { type: "boolean", default: false }
+      },
+      required: ["repo", "agent"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string" },
+        repo: { type: "string" },
+        task_id: { type: "string" },
+        task_code: { type: "string", nullable: true },
+        agent: { type: "string" },
+        role: { type: "string" },
+        claimed_at: { type: "string" },
+        released_at: { type: "string", nullable: true },
+        metadata: { type: "object" }
+      },
+      required: ["id", "repo", "task_id", "agent", "role", "claimed_at", "metadata"]
+    }
+  },
+  {
+    name: "standard-store",
+    title: "Standard Store",
+    description: "Store one atomic coding standard. Use for durable implementation rules with explicit context, stack/language filters, and repo/global scope.",
+    annotations: {
+      readOnlyHint: false,
+      idempotentHint: false,
+      destructiveHint: false,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", minLength: 3, maxLength: 255, description: "Human-readable standard name" },
+        content: { type: "string", minLength: 10, description: "One atomic, actionable standard written as concise Markdown" },
+        context: { type: "string", description: "Context or category (e.g., 'error-handling', 'security')" },
+        version: { type: "string", description: "Version of the standard (e.g., '1.0.0')" },
+        language: { type: "string", description: "Programming language (e.g., 'typescript', 'python')" },
+        stack: {
+          type: "array",
+          items: { type: "string" },
+          description: "Technology stack (e.g., ['react', 'nextjs'])"
+        },
+        repo: { type: "string", description: "Repository name for repo-specific standards. Omit only for global standards." },
+        is_global: { type: "boolean", description: "Whether standard applies globally or repo-specific" },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Tags for categorization"
+        },
+        metadata: {
+          type: "object",
+          description: "Additional metadata"
+        },
+        agent: { type: "string", description: "Agent creating the standard" },
+        model: { type: "string", description: "AI model used" },
+        structured: { type: "boolean", default: false }
+      },
+      required: ["name", "content"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        standard: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            title: { type: "string" },
+            content: { type: "string" },
+            context: { type: "string" },
+            version: { type: "string" },
+            language: { type: "string", nullable: true },
+            stack: { type: "array", items: { type: "string" } },
+            is_global: { type: "boolean" },
+            repo: { type: "string", nullable: true },
+            tags: { type: "array", items: { type: "string" } },
+            metadata: { type: "object" },
+            created_at: { type: "string" },
+            updated_at: { type: "string" },
+            agent: { type: "string" },
+            model: { type: "string" }
+          },
+          required: [
+            "id",
+            "title",
+            "content",
+            "context",
+            "version",
+            "stack",
+            "is_global",
+            "tags",
+            "metadata",
+            "created_at",
+            "updated_at",
+            "agent",
+            "model"
+          ]
+        },
+        message: { type: "string" }
+      },
+      required: ["success", "standard", "message"]
+    }
+  },
+  {
+    name: "standard-search",
+    title: "Standard Search",
+    description: "Navigation and lookup layer for coding standards. Query by text, stack, language, version, repo, and global scope before applying or creating standards.",
+    annotations: {
+      readOnlyHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search query (optional, searches title/content)" },
+        stack: {
+          type: "array",
+          items: { type: "string" },
+          description: "Technology stack to filter by (e.g., ['react', 'nextjs'])"
+        },
+        language: { type: "string", description: "Programming language filter" },
+        version: { type: "string", description: "Version filter" },
+        repo: { type: "string", description: "Repository filter (optional)" },
+        is_global: { type: "boolean", description: "Filter by global/repo-specific" },
+        limit: { type: "number", minimum: 1, maximum: 100, default: 20 },
+        offset: { type: "number", minimum: 0, default: 0 },
+        structured: { type: "boolean", default: false }
+      },
+      required: []
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        success: { type: "boolean" },
+        standards: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              id: { type: "string" },
+              title: { type: "string" },
+              content: { type: "string" },
+              context: { type: "string" },
+              version: { type: "string" },
+              language: { type: "string", nullable: true },
+              stack: { type: "array", items: { type: "string" } },
+              is_global: { type: "boolean" },
+              repo: { type: "string", nullable: true },
+              tags: { type: "array", items: { type: "string" } },
+              metadata: { type: "object" },
+              created_at: { type: "string" },
+              updated_at: { type: "string" },
+              agent: { type: "string" },
+              model: { type: "string" }
+            }
+          },
+          description: "Matching coding standards"
+        },
+        count: { type: "number", description: "Number of results returned" },
+        message: { type: "string" }
+      },
+      required: ["success", "standards", "count", "message"]
+    }
   }
 ];
 
@@ -3946,6 +4610,11 @@ export {
   TaskDeleteSchema,
   MemoryDetailSchema,
   TaskGetSchema,
+  HandoffCreateSchema,
+  HandoffListSchema,
+  TaskClaimSchema,
+  StandardStoreSchema,
+  StandardSearchSchema,
   TOOL_DEFINITIONS,
   encodeCursor,
   decodeCursor,