@gethmy/mcp 2.23.0 → 2.25.0

package/src/server.ts

@@ -29,6 +29,7 @@ import {
   untrack,
 } from "./auto-session.js";
 import {
+  describeActiveContext,
   getActiveProjectId,
   getActiveWorkspaceId,
   getApiUrl,
@@ -36,7 +37,7 @@ import {
   getUserEmail,
   isConfigured,
   saveConfig,
-  setActiveProject,
+  setActiveContext,
   setActiveWorkspace,
 } from "./config.js";
 import {
@@ -68,6 +69,7 @@ import {
 } from "./memory-session.js";
 import { lintTags, normalizeTags } from "./memory-tags.js";
 import { onboardNewUser } from "./onboard.js";
+import { collectPlaybookMetricWarnings } from "./playbook-metric-warnings.js";
 import { stripSkillPreamble } from "./skills.js";
 
 // --- Signed-upload handshake (artifacts & card attachments) ---
@@ -305,7 +307,16 @@ export interface ToolDeps {
   isConfigured: () => boolean;
   getActiveProjectId: () => string | null;
   getActiveWorkspaceId: () => string | null;
-  setActiveProject: (id: string | null) => void;
+  /**
+   * Set the active project and its workspace TOGETHER (card #893). There is no
+   * project-only setter on purpose: writing the two independently is what let a
+   * project go active in a workspace it does not belong to, after which every
+   * workspace-scoped tool read the wrong workspace silently.
+   */
+  setActiveContext: (context: {
+    projectId: string | null;
+    workspaceId: string | null;
+  }) => void;
   setActiveWorkspace: (id: string | null) => void;
   getApiUrl: () => string;
   getMemoryDir: () => string | null;
@@ -1196,7 +1207,7 @@ export const TOOLS = {
   },
   harmony_classify_card: {
     description:
-      "Classify a card with the LLM classifier: sets `intent` (plan/think/implement/review), `complexity_score` (0-10), `model_tier` (simple/advanced/research), stamps `classified_at`, and applies the type label (feature/bug/idea). Call right after creating a card to classify it in-flow. Idempotent; never touches the user-owned `model_override`.",
+      "DEPRECATED — run sizing now happens at daemon pickup and is run-scoped, so nothing reads `model_tier`, `intent` or `complexity_score` any more; this tool still writes them, but only the type label has an effect. Prefer letting card creation apply the type label. Sets `intent` (plan/think/implement/review), `complexity_score` (0-10), `model_tier` (simple/advanced/research), stamps `classified_at`, and applies the type label (feature/bug/idea). Idempotent; never touches the user-owned `model_override`.",
     inputSchema: {
       type: "object",
       properties: {
@@ -1469,11 +1480,17 @@ export const TOOLS = {
     },
   },
   harmony_set_project_context: {
-    description: "Set the active project context for subsequent operations",
+    description:
+      "Set the active project context for subsequent operations. The project's workspace is set with it, so the two can never point at different places; pass workspaceId to skip the lookup.",
     inputSchema: {
       type: "object",
       properties: {
         projectId: { type: "string" },
+        workspaceId: {
+          type: "string",
+          description:
+            "The workspace this project belongs to. Optional — looked up when omitted.",
+        },
       },
       required: ["projectId"],
     },
@@ -2364,6 +2381,22 @@ export const TOOLS = {
           description: "The playbook's ordered stage objects.",
           items: { type: "object" },
         },
+        triggerType: {
+          type: "string",
+          enum: ["manual", "auto"],
+          description:
+            "'manual' (default) — the playbook is applied by a person. 'auto' — it claims matching cards itself, and requires autoBind.",
+        },
+        autoBind: {
+          type: "object",
+          description:
+            "Auto-bind rule: {priority?: number, mode?: 'all'|'any', when: [{path, op, value}]}. Conditions are evaluated against the card's labels (lowercased), intent, complexity_score and priority with the gate operators eq/neq/gte/gt/lte/lt/contains/exists; 'contains' on labels is membership. Stored even while triggerType is 'manual', so a rule can be armed later without re-authoring it.",
+        },
+        catalogId: {
+          type: "string",
+          description:
+            "Slug of the built-in template this came from (provenance only; never used to match).",
+        },
       },
       required: ["name"],
     },
@@ -2371,7 +2404,7 @@ export const TOOLS = {
 
   harmony_update_playbook: {
     description:
-      "Update a playbook's name, description, steps/stages, enabled flag, or lifecycle state ('active'|'deprecated').",
+      "Update a playbook's name, description, steps/stages, enabled flag, lifecycle state ('active'|'deprecated'), or its auto-bind rule and arming.",
     inputSchema: {
       type: "object",
       properties: {
@@ -2395,6 +2428,17 @@ export const TOOLS = {
           enum: ["active", "deprecated"],
           description: "Lifecycle state",
         },
+        triggerType: {
+          type: "string",
+          enum: ["manual", "auto"],
+          description:
+            "Arm ('auto') or disarm ('manual') automatic application. Arming requires a rule to be present or supplied in the same call.",
+        },
+        autoBind: {
+          type: "object",
+          description:
+            "Replace the auto-bind rule: {priority?, mode?: 'all'|'any', when: [{path, op, value}]}. Pass null to remove it.",
+        },
       },
       required: ["playbookId"],
     },
@@ -3107,7 +3151,13 @@ async function handleToolCall(
           // wrong-context resolve is visible immediately.
           const established = activeProjectId == null;
           if (established) {
-            deps.setActiveProject(resolved.project.id);
+            // The pair, never the project alone (#893): `resolved.project`
+            // carries its `workspaceId`, and discarding it here is what left
+            // the active workspace pointing somewhere unrelated.
+            deps.setActiveContext({
+              projectId: resolved.project.id,
+              workspaceId: resolved.project.workspaceId,
+            });
           }
           return {
             success: true,
@@ -3790,16 +3840,97 @@ async function handleToolCall(
 
     case "harmony_set_project_context": {
       const projectId = z.string().uuid().parse(args.projectId);
-      deps.setActiveProject(projectId);
-      return { success: true, activeProjectId: projectId };
+
+      // Find the project's OWN workspace rather than keeping whichever one
+      // happened to be active (#893). The two ids are one pair; setting half of
+      // it is how a project ended up active in a foreign workspace, after which
+      // every workspace-scoped tool read the wrong one and said nothing.
+      //
+      // An explicit `workspaceId` skips the lookup. Otherwise we search the
+      // reachable workspaces, and REFUSE the whole call if that search cannot
+      // name one — we never write half a pair.
+      //
+      // Refusing beats the two alternatives. Keeping the previous workspace is
+      // the mismatch itself. Setting the project with a NULL workspace looks
+      // safe but is not: on the remote transport an unpinned workspace falls
+      // back to the grant's own, so the project would end up active inside it
+      // anyway, and on stdio the write lands in a config file that outlives the
+      // session. A project this connection cannot place is useless as context.
+      const explicitWorkspaceId = args.workspaceId
+        ? z.string().uuid().parse(args.workspaceId)
+        : null;
+
+      let owningWorkspaceId: string | null = explicitWorkspaceId;
+
+      if (!owningWorkspaceId) {
+        try {
+          const { workspaces } = await client.listWorkspaces();
+          for (const workspace of workspaces as { id?: string }[]) {
+            if (!workspace?.id) continue;
+            const { projects } = await client.listProjects(workspace.id);
+            if (
+              (projects as { id?: string }[]).some((p) => p?.id === projectId)
+            ) {
+              owningWorkspaceId = workspace.id;
+              break;
+            }
+          }
+        } catch (error) {
+          // A timeout or a 500 says nothing about where the project lives.
+          // Leave the pair untouched and say so.
+          const reason = error instanceof Error ? error.message : String(error);
+          return {
+            success: false,
+            activeProjectId: deps.getActiveProjectId(),
+            activeWorkspaceId: deps.getActiveWorkspaceId(),
+            note:
+              `Could not resolve this project's workspace (${reason}), so the ` +
+              `active context was left unchanged rather than half-written. ` +
+              `Retry, or pass workspaceId explicitly to skip the lookup.`,
+          };
+        }
+
+        if (!owningWorkspaceId) {
+          // Definitive: the listing succeeded and no reachable workspace holds
+          // this project. Setting it would produce a context whose every
+          // workspace-scoped call is wrong.
+          return {
+            success: false,
+            activeProjectId: deps.getActiveProjectId(),
+            activeWorkspaceId: deps.getActiveWorkspaceId(),
+            note:
+              `Project ${projectId} is not in any workspace this connection ` +
+              `can reach, so the active context was left unchanged. Check ` +
+              `harmony_list_projects, pass workspaceId explicitly, or ` +
+              `reconnect with /mcp if it lives in another workspace.`,
+          };
+        }
+      }
+
+      deps.setActiveContext({ projectId, workspaceId: owningWorkspaceId });
+      return {
+        success: true,
+        activeProjectId: projectId,
+        activeWorkspaceId: owningWorkspaceId,
+      };
     }
 
     case "harmony_get_context": {
+      // The rule lives in `describeActiveContext` and is called, not re-derived:
+      // a second copy of an invariant is how the two halves drifted apart in
+      // the first place. A project with no workspace still arrives from a
+      // config written before #893.
+      const report = describeActiveContext({
+        projectId: deps.getActiveProjectId(),
+        workspaceId: deps.getActiveWorkspaceId(),
+      });
       return {
         success: true,
         context: {
-          activeWorkspaceId: deps.getActiveWorkspaceId(),
-          activeProjectId: deps.getActiveProjectId(),
+          activeWorkspaceId: report.workspaceId,
+          activeProjectId: report.projectId,
+          consistent: report.consistent,
+          ...(report.note ? { note: report.note } : {}),
         },
       };
     }
@@ -4550,6 +4681,12 @@ async function handleToolCall(
                 : undefined,
             include_superseded: includeSuperseded,
             include_episodes: includeEpisodes,
+            // No consumer here on purpose (fix round 1, task 4): this fetches
+            // an over-fetched candidate pool (up to `fetchLimit`, itself
+            // padded above `requestedLimit`/`topK`) for Park to rescore, not
+            // what the tool actually returns. Recording it would overstate
+            // access_count by up to fetchLimit/finalCount per call. What we
+            // actually deliver is recorded below, after trimming.
           },
         );
         entities = (searchResult.entities ?? []) as any[];
@@ -4611,19 +4748,19 @@ async function handleToolCall(
         trimmed = fitToBudget(trimmed, budgetTokens);
       }
 
-      // Touch access counters for the entities we returned (#273, task 4).
-      // Previously this wrote `metadata._last_recall` via updateMemoryEntity,
-      // which left `access_count` at 0 forever and never updated
-      // `last_accessed_at` — the column the Park recency term actually reads.
-      // Route through batch-touch, which calls the atomic
-      // `batch_touch_knowledge_entities` RPC (access_count += 1, last_accessed_at
-      // = now) in a single round-trip. Non-blocking; best-effort.
+      // Read accounting (task 4, fix round 1): record only the entities
+      // actually delivered to the caller — after trimming and the budget
+      // pass, not the larger over-fetched candidate pool the search above
+      // deliberately left unrecorded. Routed through batch-touch, which
+      // dispatches to the same recordEntityReads/record_entity_reads path
+      // the search chokepoint uses when a consumer is given. Non-blocking;
+      // best-effort.
       if (trimmed.length > 0) {
         const touchIds = trimmed
           .map(({ entity }: { entity: any }) => entity?.id)
           .filter((id: unknown): id is string => typeof id === "string");
         if (touchIds.length > 0) {
-          client.batchTouchMemoryEntities(touchIds).catch(() => {});
+          client.batchTouchMemoryEntities(touchIds, "mcp-tool").catch(() => {});
         }
       }
 
@@ -5233,8 +5370,25 @@ async function handleToolCall(
         name,
         description: args.description as string | undefined,
         steps: args.steps,
+        // Auto-bind fields ride through untouched (#892) — the edge function
+        // owns validation, so the rule cannot be shaped here and rejected
+        // there, or vice versa.
+        triggerType: args.triggerType as string | undefined,
+        autoBind: args.autoBind,
+        catalogId: args.catalogId as string | undefined,
       });
-      return { success: true, playbook: result.playbook };
+      // #922: surface custom-gate metrics no agent declares — non-blocking,
+      // the playbook is already created.
+      const warnings = await collectPlaybookMetricWarnings(
+        client,
+        workspaceId,
+        args.steps,
+      );
+      return {
+        success: true,
+        playbook: result.playbook,
+        ...(warnings.length > 0 ? { warnings } : {}),
+      };
     }
 
     case "harmony_update_playbook": {
@@ -5245,8 +5399,24 @@ async function handleToolCall(
         steps: args.steps,
         enabled: args.enabled as boolean | undefined,
         state: args.state as string | undefined,
+        // Arming and the rule (#892). `autoBind: null` clears the rule, so the
+        // key is forwarded whenever present rather than only when truthy.
+        triggerType: args.triggerType as string | undefined,
+        ...("autoBind" in args ? { autoBind: args.autoBind } : {}),
       });
-      return { success: true, playbook: result.playbook };
+      // #922: same non-blocking metric check as create. The playbook's own
+      // workspace scopes the lookup — the active context may point elsewhere.
+      const warnings = await collectPlaybookMetricWarnings(
+        client,
+        (result.playbook as { workspace_id?: string } | undefined)
+          ?.workspace_id,
+        args.steps,
+      );
+      return {
+        success: true,
+        playbook: result.playbook,
+        ...(warnings.length > 0 ? { warnings } : {}),
+      };
     }
 
     // Deprecated (#612) — see harmony_run_playbook above.
@@ -5338,8 +5508,10 @@ async function handleToolCall(
 
       // Save config and reset client
       deps.saveConfig({ apiKey: result.apiKey.rawKey });
-      deps.setActiveWorkspace(result.workspace.id);
-      deps.setActiveProject(result.project.id);
+      deps.setActiveContext({
+        projectId: result.project.id,
+        workspaceId: result.workspace.id,
+      });
       deps.resetClient();
 
       return {
@@ -5365,7 +5537,7 @@ function createConfigDeps(): ToolDeps {
     isConfigured,
     getActiveProjectId: () => getActiveProjectId(),
     getActiveWorkspaceId: () => getActiveWorkspaceId(),
-    setActiveProject: (id) => setActiveProject(id),
+    setActiveContext: (context) => setActiveContext(context),
     setActiveWorkspace: (id) => setActiveWorkspace(id),
     getApiUrl,
     getMemoryDir: () => getMemoryDir(),

package/src/tui/setup.ts

@@ -19,8 +19,7 @@ import {
   loadConfig,
   saveConfig,
   saveLocalConfig,
-  setActiveProject,
-  setActiveWorkspace,
+  setActiveContext,
 } from "../config.js";
 import { loginWithBrowser, type OAuthTokens } from "../oauth-login.js";
 import { onboardNewUser } from "../onboard.js";
@@ -960,8 +959,10 @@ export async function runSetup(options: SetupOptions = {}): Promise<void> {
 
         // Save config immediately
         saveConfig({ apiKey, userEmail, apiUrl: API_URL });
-        setActiveWorkspace(selectedWorkspaceIdFromSignup);
-        setActiveProject(selectedProjectIdFromSignup);
+        setActiveContext({
+          workspaceId: selectedWorkspaceIdFromSignup,
+          projectId: selectedProjectIdFromSignup,
+        });
 
         p.log.success("Workspace and board created");
       } catch (error) {
@@ -1563,8 +1564,22 @@ export async function runSetup(options: SetupOptions = {}): Promise<void> {
       `  ${colors.success("\u2713")} ${colors.dim(formatPath(getLocalConfigPath(cwd), home))} ${colors.dim("(created)")}`,
     );
 
-    if (selectedWorkspaceId) setActiveWorkspace(selectedWorkspaceId);
-    if (selectedProjectId) setActiveProject(selectedProjectId);
+    // Mirror the choice into the GLOBAL default, explicitly (#893). The local
+    // file above already pins this directory; this second write is what gives a
+    // server started elsewhere — Claude Desktop, another repo — a context at
+    // all. It must say `global: true`: without it the write would find the file
+    // just created one line up and land back in it, and the global default
+    // would stay empty. One pair either way — a project is never set without
+    // its workspace.
+    if (selectedWorkspaceId || selectedProjectId) {
+      setActiveContext(
+        {
+          workspaceId: selectedWorkspaceId ?? null,
+          projectId: selectedProjectId ?? null,
+        },
+        { global: true },
+      );
+    }
   }
 
   // Step 10: Show completion message