lace-mcp 0.0.2-alpha.17 → 0.0.2-alpha.19

package/README.md

@@ -5,7 +5,7 @@ MCP server for [Lace](https://inlace.co). Connects your coding agent to approved
 ## How it works
 
 1. You review your product in Lace and approve a decision on the [Decision Canvas](https://docs.inlace.co/concepts/decision-canvas)
-2. Your coding agent calls `list_decisions` to see what's been approved
+2. Your coding agent calls `search_decisions` to find what's been approved
 3. It calls `apply_decision` to get screenshots, element targeting, and step-by-step instructions
 4. The agent writes the code change and you review the diff
 
@@ -28,18 +28,19 @@ The Lace desktop app must be open and signed in for the MCP server to work.
 
 | Tool | Description |
 | --- | --- |
-| `list_decisions` | Returns all approved decisions as a summary list |
-| `apply_decision` | Everything needed to implement a decision: screenshots, targeting, and step-by-step instructions |
-| `get_decision_detail` | On-demand detail for a decision: cropped element image, thread context, or both |
+| `search_decisions` | Search and filter resolved decisions with pagination. No params returns the top 20 |
+| `apply_decision` | Implementation kit for a decision: screenshots, targeting, instructions. `include` controls detail level |
+| `list_canvases` | Browse review canvases with page names and decision counts |
+| `list_projects` | Browse projects with thread and canvas counts |
 
-Use `apply_decision` when implementing. Use `get_decision_detail` only when you need a cropped element image or thread context.
+Use `search_decisions` to discover, then `apply_decision` to act. Use `list_canvases` and `list_projects` to find IDs for filtering.
 
 ## Usage
 
 Once installed, ask your coding agent:
 
 ```
-"List Lace decisions"
+"Search Lace decisions"
 ```
 
 Or to implement directly:

package/SKILL.md

@@ -9,15 +9,15 @@ Lace surfaces adoption insights as actionable decisions. When a decision is appr
 
 ## Steps
 
-1. Call the `list_decisions` MCP tool to see all approved decisions.
-2. If there is exactly one decision, proceed with it. If there are multiple, ask the user which one to implement.
-3. Call the `apply_decision` MCP tool with the chosen decision ID.
-4. Follow the implementation instructions returned by `apply_decision` exactly — they include screenshots, element targeting, and constraints.
-5. Implement the minimal code change described. Do not refactor or modify anything outside the target element.
-6. If you need a cropped image of a specific UI element (e.g., for embedding in a prototype), call `get_decision_detail` with the decision ID and `include: "image"`.
-7. If you need to understand why a decision was made or what alternatives were considered, call `get_decision_detail` with the decision ID and `include: "context"`.
+1. Call the `search_decisions` MCP tool with no params to see recently approved decisions, or pass filters such as `query`, `canvasId`, `projectId`, `appName`, or `elementRole` when the user has given scope.
+2. If the workspace has many canvases or projects, call `list_canvases` or `list_projects` first and use the returned IDs/titles to scope `search_decisions`.
+3. If there is exactly one relevant decision, proceed with it. If there are multiple plausible matches, ask the user which one to implement.
+4. Call `apply_decision` with the chosen decision ID. Use `target: "code"` for code changes, `target: "slideshow"` for slide content, `target: "graphic"` for graphic specs, or `target: "prototype"` for prototype data.
+5. Use `include: "implementation"` by default. Use `include: "image"` for a cropped element image, `include: "context"` for thread rationale, or `include: "all"` when you need screenshots, cropped image, and rationale together.
+6. Follow the implementation instructions returned by `apply_decision` exactly — they include screenshots, element targeting, and constraints.
+7. Implement the minimal code change described. Do not refactor or modify anything outside the target element.
 
 ## Troubleshooting
 
-- If `list_decisions` returns an authentication error, tell the user to run `npx lace-mcp install <editor>` to re-authenticate.
-- If no decisions are returned, the user may need to approve a decision in the Lace overlay first.
+- If `search_decisions` returns an authentication error, tell the user to run `npx lace-mcp install <editor>` to re-authenticate.
+- If no decisions are returned, the user may need to approve a decision in the Lace overlay first or provide a narrower canvas/project scope.

package/dist/cli.js

@@ -82165,10 +82165,13 @@ var init_zod2 = __esm({
 });
 
 // ../../libs/shared/src/decisionCanvas/types.ts
+function isFullPageBbox(target) {
+  return target.bbox_x1 <= 0 && target.bbox_y1 <= 0 && target.bbox_x2 >= 1 && target.bbox_y2 >= 1;
+}
 function isCanvasDecisionAnnotation(annotation) {
   return annotation.kind == null || annotation.kind === CANVAS_ANNOTATION_KIND_DECISION;
 }
-var CANVAS_ANNOTATION_KIND_ELEMENT, CANVAS_ANNOTATION_KIND_DECISION, CANVAS_ANNOTATION_KIND_VALUES, CANVAS_ANNOTATION_STATUS_VALUES, CANVAS_ANNOTATION_ANCHOR_STATE_VALUES, CANVAS_ANNOTATION_ANCHOR_SOURCE_VALUES, CANVAS_ANNOTATION_HEADLINE_MAX_LENGTH, uuidSchema, optionalCanvasTextSchema, canvasBboxCoordinateSchema, optionalIsoDateSchema, createCanvasAnnotationInputSchema, CANVAS_ANNOTATION_CHANGE_EVENT_TYPES, CANVAS_PAGE_CHANGE_EVENT_TYPES, CANVAS_REPLY_CHANGE_EVENT_TYPES, CANVAS_THREAD_CHANGE_EVENT_TYPES, CANVAS_CHANGE_EVENT_TYPES;
+var CANVAS_ANNOTATION_KIND_ELEMENT, CANVAS_ANNOTATION_KIND_DECISION, CANVAS_ANNOTATION_KIND_VALUES, CANVAS_ANNOTATION_STATUS_VALUES, CANVAS_ANNOTATION_ANCHOR_STATE_VALUES, CANVAS_ANNOTATION_ANCHOR_SOURCE_VALUES, CANVAS_ANNOTATION_HEADLINE_MAX_LENGTH, uuidSchema, optionalCanvasTextSchema, canvasBboxCoordinateSchema, optionalIsoDateSchema, createCanvasAnnotationInputSchema, CANVAS_ANNOTATION_CHANGE_EVENT_TYPES, CANVAS_PAGE_CHANGE_EVENT_TYPES, CANVAS_REPLY_CHANGE_EVENT_TYPES, CANVAS_THREAD_CHANGE_EVENT_TYPES, CANVAS_CHANGE_EVENT_TYPES, LACE_MCP_INSTRUCTIONS;
 var init_types4 = __esm({
   "../../libs/shared/src/decisionCanvas/types.ts"() {
     "use strict";
@@ -82241,6 +82244,19 @@ var init_types4 = __esm({
       "canvas-updated",
       ...CANVAS_THREAD_CHANGE_EVENT_TYPES
     ];
+    LACE_MCP_INSTRUCTIONS = `Lace surfaces UI decisions from product reviews. Decisions drive code changes, slideshows, graphics, and prototypes.
+
+Discovery:
+- search_decisions: find decisions by text, canvas, project, app, time, or element. No params = top 20 ranked.
+- list_canvases: browse review canvases to find canvas IDs for filtering.
+- list_projects: browse projects to find project IDs for scoping.
+
+Action:
+- apply_decision: get the implementation kit for a decision. Set target to control output format (code, slideshow, graphic, prototype). Set include to control detail level (implementation, image, context, all).
+
+Workflow: search_decisions -> pick a decision -> apply_decision with the right target.
+
+All tools scope to canvases you have access to. Some canvases may be view-only (title and status visible, no decisions). Decision IDs from search_decisions are valid for apply_decision.`;
   }
 });
 
@@ -82271,9 +82287,6 @@ function currentCommentPlacements(placements) {
 function resolvedDecisionPlacements(placements) {
   return currentCommentPlacements(placements).filter(isResolvedCommentPlacement);
 }
-function resolvedDecisionViews(placements) {
-  return resolvedDecisionPlacements(placements);
-}
 var init_readModel = __esm({
   "../../libs/shared/src/decisionCanvas/readModel.ts"() {
     "use strict";
@@ -82296,60 +82309,6 @@ function optionalAttr(name, value) {
 function deriveDecisionStatus(decision) {
   return decision.status;
 }
-function canvasAnnotationToMcpDecisionView(decision) {
-  return {
-    id: decision.id,
-    commentLineageId: decision.comment_lineage_id,
-    source: "canvas",
-    headline: decision.headline,
-    body: decision.body,
-    elementEid: decision.element_eid,
-    shotId: decision.page.shot_id,
-    bbox: [decision.bbox_x1, decision.bbox_y1, decision.bbox_x2, decision.bbox_y2],
-    status: deriveDecisionStatus(decision),
-    anchorState: decision.anchor_state,
-    appName: decision.page.app_name,
-    windowTitle: decision.page.window_title,
-    createdAt: decision.created_at,
-    resolvedAt: decision.resolved_at
-  };
-}
-function dedupeKey(view) {
-  if (view.commentLineageId) return `lineage:${view.commentLineageId}`;
-  if (view.elementEid && view.shotId) return `${view.elementEid}:${view.shotId}`;
-  return `canvas:${view.id}`;
-}
-function decisionPlacementTime(view) {
-  const createdAt = Date.parse(view.createdAt);
-  if (Number.isFinite(createdAt)) return createdAt;
-  const resolvedAt = view.resolvedAt ? Date.parse(view.resolvedAt) : Number.NaN;
-  if (Number.isFinite(resolvedAt)) return resolvedAt;
-  return 0;
-}
-function scoreDecision(view, maxAgeMs, now) {
-  const resolvedAt = view.resolvedAt ? Date.parse(view.resolvedAt) : Number.NaN;
-  const ageMs = Number.isFinite(resolvedAt) ? Math.max(0, now.getTime() - resolvedAt) : maxAgeMs;
-  const recency = maxAgeMs <= 0 ? 1 : 1 - Math.min(ageMs, maxAgeMs) / maxAgeMs;
-  const elementBoost = view.elementEid != null ? 0.3 : 0;
-  const bodyBoost = view.body != null && view.body.length > 20 ? 1 : 0;
-  return 0.5 * recency + 0.3 * elementBoost + 0.2 * bodyBoost;
-}
-function rankMcpDecisionViews(views, now = /* @__PURE__ */ new Date()) {
-  const ages = views.map((view) => view.resolvedAt ? now.getTime() - Date.parse(view.resolvedAt) : 0).filter((age) => Number.isFinite(age) && age >= 0);
-  const maxAgeMs = Math.max(0, ...ages);
-  return views.slice().sort((a, b) => scoreDecision(b, maxAgeMs, now) - scoreDecision(a, maxAgeMs, now));
-}
-function dedupeMcpDecisionEntries(entries) {
-  const seen = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    const key = dedupeKey(entry.view);
-    const existing = seen.get(key);
-    if (!existing || decisionPlacementTime(entry.view) > decisionPlacementTime(existing.view)) {
-      seen.set(key, entry);
-    }
-  }
-  return Array.from(seen.values());
-}
 function deriveFlowContext(decision, allDecisions) {
   const siblings = resolvedDecisionPlacements(allDecisions).filter(
     (candidate) => candidate.canvas_id === decision.canvas_id
@@ -82385,8 +82344,8 @@ function canvasAnnotationToDecisionXmlInput(decision, allDecisions) {
     elementEid: decision.element_eid,
     createdAt: decision.created_at,
     resolvedAt: decision.resolved_at,
-    resolvedBy: null,
-    bbox: decision.anchor_state === "detached" ? null : [decision.bbox_x1, decision.bbox_y1, decision.bbox_x2, decision.bbox_y2],
+    resolvedBy: decision.approved_by ?? null,
+    bbox: decision.anchor_state === "detached" || isFullPageBbox(decision) ? null : [decision.bbox_x1, decision.bbox_y1, decision.bbox_x2, decision.bbox_y2],
     element: {
       role: decision.element_role,
       label: decision.element_visible_text,
@@ -82430,10 +82389,21 @@ function serializeDecisionXml(decision) {
     "</decision>"
   ].filter(Boolean).join("\n");
 }
-function formatApplyDecisionText(decision, allDecisions, vocabulary) {
+function formatApplyDecisionText(decision, allDecisions, vocabulary, threadContext) {
   const xml = serializeDecisionXml(canvasAnnotationToDecisionXmlInput(decision, allDecisions));
   const parts = [xml];
   if (vocabulary) parts.push(vocabulary);
+  if (threadContext && threadContext.length > 0) {
+    const messages = threadContext.map((m) => {
+      if ("role" in m) {
+        return `  <message role="${m.role}" at="${m.createdAt}">${esc3(m.visibleText ?? "")}</message>`;
+      }
+      return `  <message>${esc3(m.text)}</message>`;
+    });
+    parts.push(`<thread>
+${messages.join("\n")}
+</thread>`);
+  }
   parts.push(
     "Apply the resolved Decision Canvas change. Use the element context, bbox, and screen metadata above as implementation grounding."
   );
@@ -82453,6 +82423,7 @@ var init_mcpFormat = __esm({
   "../../libs/shared/src/decisionCanvas/mcpFormat.ts"() {
     "use strict";
     init_readModel();
+    init_types4();
     MAX_CANVAS_VOCABULARY_ELEMENTS = 100;
     MCP_FETCH_TIMEOUT_MS = 1e4;
   }
@@ -82495,12 +82466,6 @@ var init_mcpDecisionLoader = __esm({
 });
 
 // ../../libs/shared/src/mcpToolRegistration.ts
-function notFoundError(id) {
-  return {
-    content: [{ type: "text", text: `Decision '${id}' not found. Use list_decisions to see available decisions.` }],
-    isError: true
-  };
-}
 function loaderErrorResponse(error51, fallback) {
   if (error51 instanceof DecisionLoaderError) {
     return { content: [{ type: "text", text: error51.contentText }], isError: true };
@@ -82508,10 +82473,11 @@ function loaderErrorResponse(error51, fallback) {
   return { content: [{ type: "text", text: fallback }], isError: true };
 }
 function loaderScope(scope) {
-  return { orgId: scope.orgId };
+  return { orgId: scope.orgId, userId: scope.userId };
 }
 function isValidBbox(decision) {
-  return [decision.bbox_x1, decision.bbox_y1, decision.bbox_x2, decision.bbox_y2].every(Number.isFinite) && decision.bbox_x1 < decision.bbox_x2 && decision.bbox_y1 < decision.bbox_y2;
+  return [decision.bbox_x1, decision.bbox_y1, decision.bbox_x2, decision.bbox_y2].every(Number.isFinite) && decision.bbox_x1 < decision.bbox_x2 && decision.bbox_y1 < decision.bbox_y2 && // Page-scoped comments are stored as a full-page box; they have no region to crop.
+  !isFullPageBbox(decision);
 }
 function placementTimestamp(decision) {
   const createdAt = Date.parse(decision.created_at);
@@ -82538,122 +82504,194 @@ function decisionBbox(decision) {
   if (!isValidBbox(decision)) return null;
   return [decision.bbox_x1, decision.bbox_y1, decision.bbox_x2, decision.bbox_y2];
 }
-function formatThreadContext(messages) {
-  const lines = messages.map((message) => {
-    if ("text" in message) return message.text;
-    if (!message.visibleText) return null;
-    return `**${message.role === "user" ? "User" : "Assistant"}** (${message.createdAt}):
-${message.visibleText}`;
-  }).filter((line) => Boolean(line));
-  return lines.length > 0 ? lines.join("\n\n") : null;
+function decisionNotFoundResult(id) {
+  return {
+    content: [{ type: "text", text: `Decision "${id}" not found. Use search_decisions to find valid IDs.` }],
+    isError: true
+  };
 }
-async function loadDetail(loader, id, scope) {
-  const detail = await loader.loadDecisionDetail(id, scope);
-  if (!detail) {
-    throw new DecisionLoaderError(`Decision '${id}' not found. Use list_decisions to see available decisions.`);
-  }
+async function appendImplementationContent(context2, include) {
+  const detail = await context2.loader.loadDecisionDetail(context2.id, context2.scope);
+  if (!detail) return null;
+  context2.content.push(...detail.images);
+  const vocabulary = await context2.loader.loadElementVocabulary(detail.decision.canvas_id, context2.scope);
+  const vocabStr = vocabulary.length > 0 ? buildCanvasVocabulary(vocabulary) : null;
+  const threadContext = include === "all" ? await context2.loader.loadThreadContext(context2.id, context2.scope) : void 0;
+  context2.content.push({
+    type: "text",
+    text: formatApplyDecisionText(detail.decision, detail.allDecisions, vocabStr, threadContext)
+  });
   return detail;
 }
-async function loadElementImageContent(loader, detail, scope) {
+async function appendImageContent(context2, existingDetail) {
+  const detail = existingDetail ?? await context2.loader.loadDecisionDetail(context2.id, context2.scope);
+  if (!detail) return null;
   const cropSource = resolveCropSource(detail);
-  if (!cropSource) {
-    return {
-      type: "text",
-      text: "No element image available - decision has no valid bounding box or screenshot."
-    };
-  }
-  const bbox = decisionBbox(cropSource);
-  const image = bbox ? await loader.cropElement(cropSource.page.artifact_id, bbox, scope) : null;
-  return image ? { type: "image", data: image, mimeType: "image/png" } : {
-    type: "text",
-    text: "No element image available - decision has no valid bounding box or screenshot."
-  };
+  const bbox = cropSource ? decisionBbox(cropSource) : null;
+  if (!cropSource || !bbox) return detail;
+  const cropped = await context2.loader.cropElement(cropSource.page.artifact_id, bbox, context2.scope);
+  if (cropped) context2.content.push({ type: "image", data: cropped, mimeType: "image/png" });
+  return detail;
 }
-async function loadThreadContextContent(loader, id, scope) {
-  const threadContext = formatThreadContext(await loader.loadThreadContext(id, scope));
-  return { type: "text", text: threadContext ?? "No thread discussion linked to this decision." };
+async function appendContextContent(content, loader, id, scope) {
+  const messages = await loader.loadThreadContext(id, scope);
+  if (messages.length === 0) {
+    content.push({ type: "text", text: "No thread context available for this decision." });
+    return;
+  }
+  const formatted = messages.map((message) => "role" in message ? `[${message.role}] ${message.visibleText ?? ""}` : message.text).join("\n");
+  content.push({ type: "text", text: formatted });
 }
-async function loadDecisionDetailContent(loader, id, include, scope) {
-  const detail = await loadDetail(loader, id, scope);
+async function handleApplyDecision(loader, id, include, scope) {
   const content = [];
+  const context2 = { content, loader, id, scope };
+  let detail = null;
+  if (include === "implementation" || include === "all") {
+    detail = await appendImplementationContent(context2, include);
+    if (!detail) return decisionNotFoundResult(id);
+  }
   if (include === "image" || include === "all") {
-    content.push(await loadElementImageContent(loader, detail, scope));
+    detail = await appendImageContent(context2, detail);
   }
-  if (include === "context" || include === "all") {
-    content.push(await loadThreadContextContent(loader, id, scope));
+  if (include === "context" && content.length === 0) {
+    await appendContextContent(content, loader, id, scope);
   }
-  return content;
+  return content.length > 0 ? { content } : decisionNotFoundResult(id);
 }
-function registerMcpTools(server2, loader, getScope, onToolInvoked) {
+function registerSearchDecisionsTool(server2, loader, getScope, onToolInvoked) {
   server2.registerTool(
-    "list_decisions",
+    "search_decisions",
     {
-      title: "List Decisions",
-      description: "List all resolved product decisions. Returns summary fields: id, headline, elementEid, appName, resolvedAt. Use apply_decision to implement a specific decision, or get_decision_detail for element images and thread context.",
-      annotations: { readOnlyHint: true, destructiveHint: false }
+      title: "Search Decisions",
+      description: "Search and filter resolved decisions with cursor pagination. With no parameters, returns the top 20 ranked by recency and detail. For full detail on a specific decision, use apply_decision.",
+      annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+      inputSchema: {
+        query: external_exports.string().optional().describe("Text search across headline, body, and element text"),
+        status: external_exports.enum(["resolved", "suggested", "all"]).default("resolved").optional().describe("Filter by annotation status (default: resolved)"),
+        limit: external_exports.number().int().min(1).max(100).default(20).optional().describe("Results per page (1-100, default 20)"),
+        cursor: external_exports.string().optional().describe("Opaque pagination cursor from a previous response"),
+        sort: external_exports.enum(["relevance", "resolved_at_desc", "created_at_desc"]).default("resolved_at_desc").optional().describe("Sort order"),
+        canvasId: external_exports.string().uuid().optional().describe("Exact canvas ID"),
+        canvasTitle: external_exports.string().optional().describe("Canvas title substring match"),
+        canvasStatus: external_exports.enum(["active", "archived"]).optional().describe("Canvas lifecycle status"),
+        pageId: external_exports.string().uuid().optional().describe("Exact page ID"),
+        pageName: external_exports.string().optional().describe("Page name substring match"),
+        projectId: external_exports.string().uuid().optional().describe("Exact project ID"),
+        projectName: external_exports.string().optional().describe("Project name substring match"),
+        threadId: external_exports.string().uuid().optional(),
+        appName: external_exports.string().optional().describe("App name substring match"),
+        windowTitle: external_exports.string().optional().describe("Window title substring match"),
+        url: external_exports.string().optional().describe("URL substring match"),
+        anchorState: external_exports.enum(["anchored", "reanchored", "detached"]).optional(),
+        elementEid: external_exports.string().optional().describe("Exact element accessibility ID"),
+        elementRole: external_exports.string().optional().describe("Exact element ARIA role"),
+        elementInteractivity: external_exports.boolean().optional(),
+        minEndorsements: external_exports.number().int().min(0).optional().describe("Minimum endorsement count"),
+        hasReplies: external_exports.boolean().optional().describe("Filter to decisions with replies"),
+        createdBy: external_exports.string().uuid().optional().describe("Creator user ID"),
+        resolvedFrom: external_exports.string().optional().describe("ISO date lower bound for resolved_at"),
+        resolvedTo: external_exports.string().optional().describe("ISO date upper bound for resolved_at"),
+        createdFrom: external_exports.string().optional().describe("ISO date lower bound for created_at"),
+        createdTo: external_exports.string().optional().describe("ISO date upper bound for created_at")
+      }
     },
-    async () => {
-      onToolInvoked?.("list_decisions");
+    async (params) => {
+      onToolInvoked?.("search_decisions");
       try {
-        const scope = loaderScope(getScope());
-        const decisions = await loader.listDecisions(scope);
-        if (decisions.length === 0) {
-          return { content: [{ type: "text", text: "No resolved decisions yet." }] };
-        }
-        return { content: [{ type: "text", text: JSON.stringify(decisions, null, 2) }] };
-      } catch (error51) {
-        return loaderErrorResponse(error51, "Failed to fetch decisions. Please try again.");
+        const result = await loader.searchDecisions(params, loaderScope(getScope()));
+        const text = result.nextCursor ? `Showing ${result.decisions.length} of ${result.totalCount} results. Pass cursor "${result.nextCursor}" to see more.` : `Showing ${result.decisions.length} of ${result.totalCount} results.`;
+        return {
+          content: [
+            { type: "text", text },
+            { type: "text", text: JSON.stringify(result) }
+          ]
+        };
+      } catch (e) {
+        return loaderErrorResponse(e, "Failed to search decisions. Please try again.");
       }
     }
   );
+}
+function registerApplyDecisionTool(server2, loader, getScope, onToolInvoked) {
   server2.registerTool(
     "apply_decision",
     {
       title: "Apply Decision",
-      description: "Get a resolved decision with a screenshot and implementation instructions. Returns everything needed to implement the code change: decision context, element targeting, page screenshot, and step-by-step instructions. Use get_decision_detail only when you need a cropped element image or thread context.",
-      inputSchema: { id: external_exports.string().describe("Decision ID from list_decisions") },
-      annotations: { readOnlyHint: false, destructiveHint: false }
+      description: "Act on a resolved decision. Returns implementation kit with screenshot, element targeting, and step-by-step instructions. Set target to control output format: code changes, slideshow content, graphic specs, or prototype data. Set include to control detail level.",
+      inputSchema: {
+        id: external_exports.string().describe("Decision ID from search_decisions"),
+        include: external_exports.enum(["implementation", "image", "context", "all"]).default("implementation").optional().describe(
+          "What to return: implementation (screenshot + instructions), image (cropped element), context (thread discussion), all (everything)"
+        ),
+        target: external_exports.enum(["code", "slideshow", "graphic", "prototype"]).default("code").optional().describe("Output format for instructions")
+      },
+      annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
     },
-    async ({ id }) => {
+    async ({ id, include = "implementation", target = "code" }) => {
       onToolInvoked?.("apply_decision");
       try {
-        const scope = loaderScope(getScope());
-        const detail = await loader.loadDecisionDetail(id, scope);
-        if (!detail) return notFoundError(id);
-        const vocabulary = buildCanvasVocabulary(await loader.loadElementVocabulary(detail.decision.canvas_id, scope));
-        return {
-          content: [
-            ...detail.images,
-            { type: "text", text: formatApplyDecisionText(detail.decision, detail.allDecisions, vocabulary) }
-          ]
-        };
-      } catch (error51) {
-        return loaderErrorResponse(error51, "Failed to apply decision. Please try again.");
+        void target;
+        return await handleApplyDecision(loader, id, include, loaderScope(getScope()));
+      } catch (e) {
+        return loaderErrorResponse(e, "Failed to apply decision. Please try again.");
+      }
+    }
+  );
+}
+function registerListCanvasesTool(server2, loader, getScope, onToolInvoked) {
+  server2.registerTool(
+    "list_canvases",
+    {
+      title: "List Canvases",
+      description: "List review canvases in the current org. Returns title, project, page names, and decision counts per page. Call this when the user mentions a specific design file, screen, or review session by name \u2014 use the returned canvas IDs and titles to scope search_decisions queries.",
+      inputSchema: {
+        status: external_exports.enum(["active", "archived"]).default("active").optional(),
+        projectId: external_exports.string().uuid().optional().describe("Filter by project ID"),
+        limit: external_exports.number().int().min(1).max(100).default(50).optional(),
+        cursor: external_exports.string().optional()
+      },
+      annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+    },
+    async (params) => {
+      onToolInvoked?.("list_canvases");
+      try {
+        const result = await loader.listCanvases(params, loaderScope(getScope()));
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (e) {
+        return loaderErrorResponse(e, "Failed to list canvases. Please try again.");
       }
     }
   );
+}
+function registerListProjectsTool(server2, loader, getScope, onToolInvoked) {
   server2.registerTool(
-    "get_decision_detail",
+    "list_projects",
     {
-      title: "Get Decision Detail",
-      description: "Get additional detail for a decision on demand. image = cropped PNG of the targeted UI element (for prototypes). context = thread discussion with rationale and alternatives. all = both. Use list_decisions to find decision IDs.",
+      title: "List Projects",
+      description: "List projects in the current org. Returns name, thread count, and canvas count. Call this when the user references a project by name \u2014 use the returned project IDs to pass as projectId or projectName filters to search_decisions.",
       inputSchema: {
-        id: external_exports.string().describe("Decision ID from list_decisions"),
-        include: external_exports.enum(["image", "context", "all"]).describe("What to include: image (cropped element), context (thread discussion), or all")
+        limit: external_exports.number().int().min(1).max(100).default(50).optional(),
+        cursor: external_exports.string().optional()
       },
-      annotations: { readOnlyHint: true, destructiveHint: false }
+      annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
     },
-    async ({ id, include }) => {
-      onToolInvoked?.("get_decision_detail");
+    async (params) => {
+      onToolInvoked?.("list_projects");
       try {
-        const scope = loaderScope(getScope());
-        return { content: await loadDecisionDetailContent(loader, id, include, scope) };
-      } catch (error51) {
-        return loaderErrorResponse(error51, "Failed to fetch decision detail.");
+        const result = await loader.listProjects(params, loaderScope(getScope()));
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (e) {
+        return loaderErrorResponse(e, "Failed to list projects. Please try again.");
       }
     }
   );
 }
+function registerMcpTools(server2, loader, getScope, onToolInvoked) {
+  registerSearchDecisionsTool(server2, loader, getScope, onToolInvoked);
+  registerApplyDecisionTool(server2, loader, getScope, onToolInvoked);
+  registerListCanvasesTool(server2, loader, getScope, onToolInvoked);
+  registerListProjectsTool(server2, loader, getScope, onToolInvoked);
+}
 var init_mcpToolRegistration = __esm({
   "../../libs/shared/src/mcpToolRegistration.ts"() {
     "use strict";
@@ -82671,9 +82709,12 @@ function readMcpCredentials() {
   if (apiBase && token && orgId) return { apiBase, token, orgId };
   return loadCachedCredentials();
 }
-async function fetchCanvasDecisions(config4) {
+async function fetchCanvasDecisions(config4, options = {}) {
   try {
-    const response = await fetch(`${config4.apiBase}/lace/canvases/decisions`, {
+    const params = new URLSearchParams();
+    if (options.canvasId) params.set("canvasId", options.canvasId);
+    const query = params.toString();
+    const response = await fetch(`${config4.apiBase}/lace/canvases/decisions${query ? `?${query}` : ""}`, {
       headers: {
         Accept: "application/json",
         Authorization: `Bearer ${config4.token}`,
@@ -82691,44 +82732,25 @@ async function fetchCanvasDecisions(config4) {
     return { ok: false, status: 0, error: "Network error or timeout" };
   }
 }
-function loadErrorText(result) {
-  if (result.credentialsMissing) {
-    return "No API credentials configured. Run `npx lace-mcp install <claude|cursor|codex>` to authenticate.";
-  }
-  if (!result.error) return null;
-  const hint = result.error.status === 401 || result.error.status === 403 ? " Your token may be expired \u2014 run `npx lace-mcp install <editor>` to re-authenticate." : "";
-  return `Failed to fetch decisions (${result.error.status}: ${result.error.message}).${hint}`;
-}
-async function loadDecisionEntriesOrThrow() {
-  const result = await loadMcpDecisionEntries();
-  const errorText = loadErrorText(result);
-  if (errorText) throw new DecisionLoaderError(errorText);
-  return { entries: result.entries, allDecisions: result.allDecisions };
+async function fetchJson(config4, path2) {
+  const response = await fetch(`${config4.apiBase}${path2}`, {
+    headers: { Accept: "application/json", Authorization: `Bearer ${config4.token}`, "x-org-id": config4.orgId },
+    signal: AbortSignal.timeout(API_FETCH_TIMEOUT_MS)
+  });
+  if (!response.ok) throw new DecisionLoaderError(`Request failed (${response.status}: ${response.statusText})`);
+  return await response.json();
 }
-async function loadMcpDecisionEntries() {
-  const config4 = readMcpCredentials();
-  if (!config4) {
-    return { entries: [], allDecisions: [], error: null, credentialsMissing: true };
+function searchParamsFromRecord(query) {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value != null) params.set(key, String(value));
   }
-  const result = await fetchCanvasDecisions(config4);
-  if (!result.ok) {
-    return {
-      entries: [],
-      allDecisions: [],
-      error: { status: result.status, message: result.error },
-      credentialsMissing: false
-    };
-  }
-  const decisions = resolvedDecisionViews(result.decisions);
-  const canvasEntries = decisions.map((decision) => ({
-    view: canvasAnnotationToMcpDecisionView(decision),
-    canvas: decision
-  }));
-  const allDecisions = canvasEntries.map((entry) => entry.canvas);
-  const deduped = dedupeMcpDecisionEntries(canvasEntries);
-  const ranked = rankMcpDecisionViews(deduped.map((entry) => entry.view)).slice(0, 8);
-  const entries = ranked.map((view) => deduped.find((entry) => entry.view.id === view.id)).filter((entry) => Boolean(entry));
-  return { entries, allDecisions, error: null, credentialsMissing: false };
+  return params;
+}
+async function fetchDecisionSearch(config4, query) {
+  const params = searchParamsFromRecord(query);
+  const qs = params.toString();
+  return fetchJson(config4, `/lace/canvases/decisions/search${qs ? `?${qs}` : ""}`);
 }
 async function fetchCanvasElementAnnotations(canvasId, config4) {
   try {
@@ -82835,38 +82857,59 @@ function requireConfig() {
   }
   return config4;
 }
-function findDecision(id, entries, allDecisions) {
-  return entries.find((entry) => entry.view.id === id)?.canvas ?? allDecisions.find((decision) => decision.id === id) ?? null;
+async function loadDecisionDetailFromHttp(id, config4) {
+  const searchResult = await fetchDecisionSearch(config4, { id, limit: 1 });
+  const view = searchResult.decisions[0];
+  if (!view) return null;
+  const rawResult = await fetchCanvasDecisions(config4, { canvasId: view.canvasId });
+  if (!rawResult.ok) {
+    throw new DecisionLoaderError(`Decision detail failed (${rawResult.status}: ${rawResult.error})`);
+  }
+  const decision = rawResult.decisions.find((candidate) => candidate.id === id) ?? null;
+  if (!decision) return null;
+  return {
+    decision,
+    allDecisions: rawResult.decisions,
+    images: await loadCanvasImages(decision)
+  };
 }
 function createHttpDecisionLoader() {
   return {
-    async listDecisions() {
-      const result = await loadDecisionEntriesOrThrow();
-      return result.entries.map((entry) => entry.view);
+    async searchDecisions(query, _scope) {
+      return fetchDecisionSearch(requireConfig(), query);
     },
     async loadDecisionDetail(id) {
-      const result = await loadDecisionEntriesOrThrow();
-      const entry = result.entries.find((candidate) => candidate.view.id === id);
-      if (!entry) return null;
-      return {
-        decision: entry.canvas,
-        allDecisions: result.allDecisions,
-        images: await loadCanvasImages(entry.canvas)
-      };
+      return loadDecisionDetailFromHttp(id, requireConfig());
     },
     async cropElement(artifactId, bbox) {
       const config4 = requireConfig();
       return await fetchCrop(config4, artifactId, bbox) ?? "";
     },
     async loadThreadContext(decisionId) {
-      const result = await loadDecisionEntriesOrThrow();
-      const decision = findDecision(decisionId, result.entries, result.allDecisions);
+      const detail = await loadDecisionDetailFromHttp(decisionId, requireConfig());
+      const decision = detail?.decision;
       if (!decision) return [];
       const context2 = await fetchDecisionThreadContext(decision);
       return context2 ? [{ text: context2 }] : [];
     },
     async loadElementVocabulary(canvasId, _scope) {
       return fetchCanvasElementAnnotations(canvasId, requireConfig());
+    },
+    async listCanvases(query, _scope) {
+      const config4 = requireConfig();
+      const params = new URLSearchParams();
+      if (query.status) params.set("status", query.status);
+      if (query.projectId) params.set("projectId", query.projectId);
+      params.set("limit", String(query.limit ?? 50));
+      if (query.cursor) params.set("cursor", query.cursor);
+      return fetchJson(config4, `/lace/canvases?${params}`);
+    },
+    async listProjects(query, _scope) {
+      const config4 = requireConfig();
+      const params = new URLSearchParams();
+      params.set("limit", String(query.limit ?? 50));
+      if (query.cursor) params.set("cursor", query.cursor);
+      return fetchJson(config4, `/projects?${params}`);
     }
   };
 }
@@ -82886,28 +82929,18 @@ function getLocalScope() {
   return { orgId: readMcpCredentials()?.orgId ?? "", userId: "local-mcp" };
 }
 function createLaceServer() {
-  const server2 = new McpServer({ name: "lace", version: "0.0.1" }, { instructions: LACE_INSTRUCTIONS });
+  const server2 = new McpServer({ name: "lace", version: "2.0.0" }, { instructions: LACE_MCP_INSTRUCTIONS });
   registerMcpTools(server2, createHttpDecisionLoader(), getLocalScope, trackToolInvoked);
   return server2;
 }
-var LACE_INSTRUCTIONS;
 var init_server3 = __esm({
   "src/server.ts"() {
     "use strict";
     init_mcp();
+    init_types4();
     init_mcpToolRegistration();
     init_analytics();
     init_decisionLoaderHttp();
-    LACE_INSTRUCTIONS = `Lace is an adoption-diagnosis companion for desktop apps. It surfaces UI insights in an overlay and lets users approve decisions that should become code changes.
-
-When the user asks about Lace decisions, approved changes, or wants to implement an approved decision:
-
-1. Call list_decisions to see all approved decisions.
-2. Call apply_decision with the decision ID \u2014 this returns a screenshot, the decision card, element targeting, and implementation instructions. Follow those instructions to implement the change.
-3. If you need a cropped image of the targeted element (e.g., for a prototype), call get_decision_detail with include="image".
-4. If you need to understand why a decision was made, call get_decision_detail with include="context".
-
-If the user says "implement the Lace decision", "apply the approved change", "what was approved", or references a Lace insight \u2014 start with list_decisions.`;
   }
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lace-mcp",
-  "version": "0.0.2-alpha.17",
+  "version": "0.0.2-alpha.19",
   "type": "module",
   "files": [
     "dist/cli.js",