stagent 0.10.0 → 0.11.1

package/src/lib/chat/tools/blueprint-tools.ts

@@ -0,0 +1,190 @@
+import { defineTool } from "../tool-registry";
+import { z } from "zod";
+import { ok, err, type ToolContext } from "./helpers";
+
+export function blueprintTools(ctx: ToolContext) {
+  return [
+    defineTool(
+      "list_blueprints",
+      "List available workflow blueprints. Blueprints are reusable workflow templates with configurable variables. Use instantiate_blueprint to create a workflow from one.",
+      {
+        domain: z
+          .enum(["work", "personal"])
+          .optional()
+          .describe("Filter by domain"),
+        search: z
+          .string()
+          .optional()
+          .describe("Search in name, description, and tags"),
+      },
+      async (args) => {
+        try {
+          const { listBlueprints } = await import(
+            "@/lib/workflows/blueprints/registry"
+          );
+          let blueprints = listBlueprints();
+
+          if (args.domain) {
+            blueprints = blueprints.filter((b) => b.domain === args.domain);
+          }
+          if (args.search) {
+            const q = args.search.toLowerCase();
+            blueprints = blueprints.filter(
+              (b) =>
+                b.name.toLowerCase().includes(q) ||
+                b.description.toLowerCase().includes(q) ||
+                b.tags.some((t) => t.toLowerCase().includes(q))
+            );
+          }
+
+          return ok(
+            blueprints.map((b) => ({
+              id: b.id,
+              name: b.name,
+              description: b.description,
+              domain: b.domain,
+              pattern: b.pattern,
+              tags: b.tags,
+              difficulty: b.difficulty,
+              estimatedDuration: b.estimatedDuration,
+              isBuiltin: b.isBuiltin,
+              variableCount: b.variables.length,
+              stepCount: b.steps.length,
+            }))
+          );
+        } catch (e) {
+          return err(
+            e instanceof Error ? e.message : "Failed to list blueprints"
+          );
+        }
+      }
+    ),
+
+    defineTool(
+      "get_blueprint",
+      "Get full details of a workflow blueprint, including its variables and steps. Use this to understand what inputs are needed before calling instantiate_blueprint.",
+      {
+        blueprintId: z.string().describe("The blueprint ID to look up"),
+      },
+      async (args) => {
+        try {
+          const { getBlueprint } = await import(
+            "@/lib/workflows/blueprints/registry"
+          );
+          const blueprint = getBlueprint(args.blueprintId);
+          if (!blueprint)
+            return err(`Blueprint not found: ${args.blueprintId}`);
+          return ok(blueprint);
+        } catch (e) {
+          return err(
+            e instanceof Error ? e.message : "Failed to get blueprint"
+          );
+        }
+      }
+    ),
+
+    defineTool(
+      "instantiate_blueprint",
+      "Create a draft workflow from a blueprint by filling in its variables. The workflow is created in 'draft' status — use execute_workflow to run it. Call get_blueprint first to see required variables.",
+      {
+        blueprintId: z
+          .string()
+          .describe("The blueprint ID to instantiate"),
+        variables: z
+          .record(z.string(), z.unknown())
+          .describe(
+            "Key-value map of variable values. Keys are variable IDs from the blueprint. Required variables must be provided."
+          ),
+        projectId: z
+          .string()
+          .optional()
+          .describe(
+            "Project ID to attach the workflow to. Omit to use the active project."
+          ),
+      },
+      async (args) => {
+        try {
+          const { instantiateBlueprint } = await import(
+            "@/lib/workflows/blueprints/instantiator"
+          );
+          const effectiveProjectId =
+            args.projectId ?? ctx.projectId ?? undefined;
+
+          const result = await instantiateBlueprint(
+            args.blueprintId,
+            args.variables,
+            effectiveProjectId
+          );
+
+          ctx.onToolResult?.("instantiate_blueprint", result);
+          return ok({
+            workflowId: result.workflowId,
+            name: result.name,
+            stepsCount: result.stepsCount,
+            skippedSteps: result.skippedSteps,
+            status: "draft",
+            message:
+              "Workflow created from blueprint. Use execute_workflow to run it.",
+          });
+        } catch (e) {
+          return err(
+            e instanceof Error ? e.message : "Failed to instantiate blueprint"
+          );
+        }
+      }
+    ),
+
+    defineTool(
+      "create_blueprint",
+      "Create a custom workflow blueprint from YAML content. The YAML must include id, name, description, version, domain, tags, pattern, variables, and steps. Use get_blueprint on an existing blueprint to see the expected structure.",
+      {
+        yaml: z
+          .string()
+          .describe(
+            "Full blueprint YAML content. Must validate against the blueprint schema."
+          ),
+      },
+      async (args) => {
+        try {
+          const { createBlueprint } = await import(
+            "@/lib/workflows/blueprints/registry"
+          );
+          const blueprint = createBlueprint(args.yaml);
+          ctx.onToolResult?.("create_blueprint", blueprint);
+          return ok({
+            id: blueprint.id,
+            name: blueprint.name,
+            message: "Blueprint created successfully",
+          });
+        } catch (e) {
+          return err(
+            e instanceof Error ? e.message : "Failed to create blueprint"
+          );
+        }
+      }
+    ),
+
+    defineTool(
+      "delete_blueprint",
+      "Delete a custom workflow blueprint. Built-in blueprints cannot be deleted.",
+      {
+        blueprintId: z.string().describe("The blueprint ID to delete"),
+      },
+      async (args) => {
+        try {
+          const { deleteBlueprint } = await import(
+            "@/lib/workflows/blueprints/registry"
+          );
+          deleteBlueprint(args.blueprintId);
+          return ok({
+            message: `Blueprint "${args.blueprintId}" deleted`,
+          });
+        } catch (e) {
+          return err(
+            e instanceof Error ? e.message : "Failed to delete blueprint"
+          );
+        }
+      }
+    ),
+  ];
+}

package/src/lib/chat/tools/helpers.ts

@@ -10,6 +10,8 @@ import type { SQLiteColumn } from "drizzle-orm/sqlite-core";
 /** Context passed to each tool factory — provides project scoping and entity callbacks. */
 export interface ToolContext {
   projectId?: string | null;
+  /** Absolute path to the active project's working directory. Used by profile tools to surface filesystem skills. */
+  projectDir?: string | null;
   onToolResult?: (toolName: string, result: unknown) => void;
 }
 

package/src/lib/chat/tools/profile-tools.ts

@@ -2,30 +2,42 @@ import { defineTool } from "../tool-registry";
 import { z } from "zod";
 import { ok, err, type ToolContext } from "./helpers";
 
-export function profileTools(_ctx: ToolContext) {
-  return [
-    defineTool(
-      "list_profiles",
-      "List all available agent profiles with their capabilities and compatible runtimes.",
-      {},
-      async () => {
-        try {
-          const { listProfiles } = await import("@/lib/agents/profiles/registry");
-          const profiles = listProfiles();
-          return ok(
-            profiles.map((p) => ({
-              id: p.id,
-              name: p.name,
-              description: p.description,
-              domain: p.domain,
-              tags: p.tags,
-            }))
-          );
-        } catch (e) {
-          return err(e instanceof Error ? e.message : "Failed to list profiles");
-        }
+/**
+ * Factory for the list_profiles tool, parameterized by projectDir so it can
+ * surface project filesystem skills alongside registry profiles via
+ * listFusedProfiles. See features/chat-claude-sdk-skills.md.
+ */
+export function getListProfilesTool(projectDir: string | null) {
+  return defineTool(
+    "list_profiles",
+    "List all available agent profiles and filesystem skills with their capabilities and compatible runtimes.",
+    {},
+    async () => {
+      try {
+        const { listFusedProfiles } = await import(
+          "@/lib/agents/profiles/list-fused-profiles"
+        );
+        const profiles = await listFusedProfiles(projectDir);
+        return ok(
+          profiles.map((p) => ({
+            id: p.id,
+            name: p.name,
+            description: p.description,
+            domain: p.domain,
+            tags: p.tags,
+            origin: p.origin ?? "registry",
+          }))
+        );
+      } catch (e) {
+        return err(e instanceof Error ? e.message : "Failed to list profiles");
       }
-    ),
+    }
+  );
+}
+
+export function profileTools(ctx: ToolContext) {
+  return [
+    getListProfilesTool(ctx.projectDir ?? null),
 
     defineTool(
       "get_profile",
@@ -44,5 +56,90 @@ export function profileTools(_ctx: ToolContext) {
         }
       }
     ),
+
+    defineTool(
+      "create_profile",
+      "Create a new agent profile with a configuration and system prompt (SKILL.md). The profile is saved to ~/.claude/skills/ and becomes immediately available. Use get_profile on an existing profile to see the expected config structure.",
+      {
+        config: z.object({
+          id: z.string().min(1).describe("Unique profile ID (kebab-case, e.g. 'my-analyst')"),
+          name: z.string().min(1).describe("Human-readable profile name"),
+          version: z.string().regex(/^\d+\.\d+\.\d+$/).describe("Semver version, e.g. '1.0.0'"),
+          domain: z.enum(["work", "personal"]).describe("Profile domain"),
+          tags: z.array(z.string()).describe("Searchable tags"),
+          maxTurns: z.number().positive().optional().describe("Max agent turns per task"),
+          outputFormat: z.string().optional().describe("Expected output format hint"),
+          author: z.string().optional().describe("Profile author"),
+        }).describe("Profile configuration object"),
+        skillMd: z.string().min(1).describe(
+          "The SKILL.md content — this is the system prompt that defines the agent's behavior, personality, and instructions. Markdown format."
+        ),
+      },
+      async (args) => {
+        try {
+          const { createProfile } = await import("@/lib/agents/profiles/registry");
+          createProfile(args.config, args.skillMd);
+          ctx.onToolResult?.("create_profile", { id: args.config.id, name: args.config.name });
+          return ok({
+            id: args.config.id,
+            name: args.config.name,
+            message: "Profile created successfully",
+          });
+        } catch (e) {
+          return err(e instanceof Error ? e.message : "Failed to create profile");
+        }
+      }
+    ),
+
+    defineTool(
+      "update_profile",
+      "Update an existing agent profile's configuration and/or system prompt. Built-in profiles cannot be modified — duplicate them first with create_profile.",
+      {
+        profileId: z.string().describe("The profile ID to update"),
+        config: z.object({
+          id: z.string().min(1),
+          name: z.string().min(1),
+          version: z.string().regex(/^\d+\.\d+\.\d+$/),
+          domain: z.enum(["work", "personal"]),
+          tags: z.array(z.string()),
+          maxTurns: z.number().positive().optional(),
+          outputFormat: z.string().optional(),
+          author: z.string().optional(),
+        }).describe("Full profile configuration (replaces existing)"),
+        skillMd: z.string().min(1).describe("Updated SKILL.md content"),
+      },
+      async (args) => {
+        try {
+          const { updateProfile } = await import("@/lib/agents/profiles/registry");
+          updateProfile(args.profileId, args.config, args.skillMd);
+          ctx.onToolResult?.("update_profile", { id: args.profileId });
+          return ok({
+            id: args.profileId,
+            message: "Profile updated successfully",
+          });
+        } catch (e) {
+          return err(e instanceof Error ? e.message : "Failed to update profile");
+        }
+      }
+    ),
+
+    defineTool(
+      "delete_profile",
+      "Delete a custom agent profile. Built-in profiles cannot be deleted.",
+      {
+        profileId: z.string().describe("The profile ID to delete"),
+      },
+      async (args) => {
+        try {
+          const { deleteProfile } = await import("@/lib/agents/profiles/registry");
+          deleteProfile(args.profileId);
+          return ok({
+            message: `Profile "${args.profileId}" deleted`,
+          });
+        } catch (e) {
+          return err(e instanceof Error ? e.message : "Failed to delete profile");
+        }
+      }
+    ),
   ];
 }

package/src/lib/chat/tools/skill-tools.ts

@@ -0,0 +1,183 @@
+import { z } from "zod";
+import { defineTool } from "../tool-registry";
+import { ok, err, type ToolContext } from "./helpers";
+
+/**
+ * Stagent MCP tools for conversation-scoped skill management.
+ *
+ * Primary consumer: Ollama — the HTTP chat-completion API has no native
+ * concept of skills, so Stagent takes over: activate a skill (persist to
+ * conversations.active_skill_id) → context builder injects its SKILL.md
+ * into Tier 0 of every subsequent turn.
+ *
+ * Secondary consumer: Claude and Codex runtimes may also call these tools
+ * for a programmatic skill-activation path alongside their native Skill
+ * handling. The tools themselves are runtime-agnostic — they just bind
+ * skill IDs to conversation rows.
+ *
+ * See `features/chat-ollama-native-skills.md`.
+ */
+
+// `mergeActiveSkillIds` lives in `@/lib/chat/active-skills` so client code
+// can import the pure helper without pulling this module's `db` import.
+// Re-exported here for back-compat with existing callers (tests, etc.).
+import { mergeActiveSkillIds } from "@/lib/chat/active-skills";
+export { mergeActiveSkillIds };
+
+export function skillTools(_ctx: ToolContext) {
+  return [
+    defineTool(
+      "list_skills",
+      "List all Stagent-discoverable skills across user (~/.claude, ~/.codex) and project (.claude, .agents) scopes. Returns id, name, tool persona, scope, and a short preview for each. Pass `enriched: true` for additional per-skill metadata (healthScore, syncStatus, linkedProfileId). Read-only.",
+      {
+        enriched: z
+          .boolean()
+          .optional()
+          .describe(
+            "When true, include healthScore ('healthy'|'stale'|'aging'|'unknown'), syncStatus ('synced'|'claude-only'|'codex-only'|'shared'), and linkedProfileId per skill."
+          ),
+      },
+      async (args) => {
+        try {
+          if (args.enriched) {
+            const { listSkillsEnriched } = await import("@/lib/environment/list-skills");
+            const skills = listSkillsEnriched();
+            return ok({
+              count: skills.length,
+              skills: skills.map((s) => ({
+                id: s.id,
+                name: s.name,
+                tool: s.tool,
+                scope: s.scope,
+                preview: s.preview,
+                sizeBytes: s.sizeBytes,
+                healthScore: s.healthScore,
+                syncStatus: s.syncStatus,
+                linkedProfileId: s.linkedProfileId,
+              })),
+            });
+          }
+          const { listSkills } = await import("@/lib/environment/list-skills");
+          const skills = listSkills();
+          return ok({
+            count: skills.length,
+            skills: skills.map((s) => ({
+              id: s.id,
+              name: s.name,
+              tool: s.tool,
+              scope: s.scope,
+              preview: s.preview,
+              sizeBytes: s.sizeBytes,
+            })),
+          });
+        } catch (e) {
+          return err(e instanceof Error ? e.message : "list_skills failed");
+        }
+      }
+    ),
+
+    defineTool(
+      "get_skill",
+      "Return the full SKILL.md content plus metadata for a single skill, identified by the id returned from list_skills. Use this to preview a skill before activating it.",
+      {
+        id: z
+          .string()
+          .describe("Opaque skill ID (from list_skills). Typically the relative path."),
+      },
+      async (args) => {
+        try {
+          const { getSkill } = await import("@/lib/environment/list-skills");
+          const skill = getSkill(args.id);
+          if (!skill) return err(`Skill not found: ${args.id}`);
+          return ok({
+            id: skill.id,
+            name: skill.name,
+            tool: skill.tool,
+            scope: skill.scope,
+            sizeBytes: skill.sizeBytes,
+            content: skill.content,
+          });
+        } catch (e) {
+          return err(e instanceof Error ? e.message : "get_skill failed");
+        }
+      }
+    ),
+
+    defineTool(
+      "activate_skill",
+      "Activate a skill on a conversation. While active, the skill's SKILL.md is injected into the system prompt on every subsequent turn. Default mode 'replace' clears any prior active skills and binds just this one. Pass mode='add' to compose multiple skills (gated by runtime — Ollama refuses; Claude/Codex/direct allow up to 3). Pass force=true to skip conflict warnings on add.",
+      {
+        conversationId: z.string().describe("ID of the conversation to bind the skill to."),
+        skillId: z.string().describe("Opaque skill ID from list_skills (typically the relative path)."),
+        mode: z
+          .enum(["replace", "add"])
+          .optional()
+          .default("replace")
+          .describe("'replace' (default) clears prior active skills; 'add' appends — runtime must support composition."),
+        force: z
+          .boolean()
+          .optional()
+          .default(false)
+          .describe("When mode='add', skip the conflict heuristic check and add anyway."),
+      },
+      async (args) => {
+        const { activateSkill } = await import("@/lib/chat/skill-composition");
+        const result = await activateSkill({
+          conversationId: args.conversationId,
+          skillId: args.skillId,
+          mode: args.mode,
+          force: args.force,
+        });
+
+        if (result.kind === "error") return err(result.message);
+
+        if (result.kind === "conflicts") {
+          return ok({
+            conversationId: args.conversationId,
+            requiresConfirmation: true,
+            conflicts: result.conflicts,
+            hint: "Re-call activate_skill with force=true to add anyway",
+          });
+        }
+
+        // kind === "ok"
+        if (result.note === "skill already active") {
+          return ok({
+            conversationId: args.conversationId,
+            activeSkillIds: result.activeSkillIds,
+            note: result.note,
+          });
+        }
+
+        return ok({
+          conversationId: args.conversationId,
+          activatedSkillId: result.activatedSkillId,
+          activeSkillIds: result.activeSkillIds,
+          skillName: result.skillName,
+        });
+      }
+    ),
+
+    defineTool(
+      "deactivate_skill",
+      "Clear the active skill on a conversation. After this call, subsequent turns will not include any Stagent-injected SKILL.md in the system prompt.",
+      {
+        conversationId: z
+          .string()
+          .describe("ID of the conversation to clear the active skill from."),
+      },
+      async (args) => {
+        const { deactivateSkill } = await import("@/lib/chat/skill-composition");
+        const result = await deactivateSkill({ conversationId: args.conversationId });
+
+        if (result.kind === "error") return err(result.message);
+
+        return ok({
+          conversationId: args.conversationId,
+          previousSkillId: result.previousSkillId,
+          activeSkillId: null,
+        });
+      }
+    ),
+  ];
+}

package/src/lib/chat/tools/task-tools.ts

@@ -324,7 +324,7 @@ export function taskTools(ctx: ToolContext) {
             );
           }
 
-          const runtimeId = args.assignedAgent ?? task.assignedAgent ?? DEFAULT_AGENT_RUNTIME;
+          const runtimeId = args.assignedAgent ?? task.assignedAgent ?? null;
 
           // Set status to queued
           await db
@@ -337,7 +337,11 @@ export function taskTools(ctx: ToolContext) {
           executeTaskWithAgent(taskId, runtimeId).catch(() => {});
 
           ctx.onToolResult?.("execute_task", { id: taskId, title: task.title });
-          return ok({ message: "Execution started", taskId, runtime: runtimeId });
+          return ok({
+            message: "Execution started",
+            taskId,
+            runtime: runtimeId ?? DEFAULT_AGENT_RUNTIME,
+          });
         } catch (e) {
           return err(e instanceof Error ? e.message : "Failed to execute task");
         }

package/src/lib/chat/tools/workflow-tools.ts

@@ -21,30 +21,68 @@ const VALID_WORKFLOW_STATUSES = [
   "failed",
 ] as const;
 
-/** Minimum Jaccard score for two workflows to count as "near duplicates". */
+/**
+ * Minimum weighted-Jaccard score for two workflows to count as "near
+ * duplicates". Combined score = NAME_WEIGHT * nameJaccard +
+ * STEPS_WEIGHT * stepsJaccard.
+ *
+ * Why weighted-and-split rather than a single pooled Jaccard? A pooled
+ * Jaccard over name+step text at threshold 0.7 was flagging legitimate
+ * target-entity variants (e.g. "Enrich contacts" vs "Enrich accounts",
+ * "Daily standup digest" vs "Weekly standup digest") as duplicates,
+ * forcing users to pass `force: true` for every such pair and eroding
+ * trust in the guardrail. Splitting the signal lets the one-token
+ * difference in names AND prompts contribute to two independent
+ * Jaccards, which together pull combined similarity below 0.7 while
+ * structural duplicates (identical steps + near-identical name) still
+ * exceed the threshold.
+ *
+ * Tuning rationale:
+ * - 0.7 threshold preserved from the original implementation.
+ * - 0.5/0.5 weights (no tags). The feature spec sketched a 0.3/0.5/0.2
+ *   split over name/steps/tags, but workflows do not persist tags in
+ *   their definition JSON today. Without a tags signal, 0.5/0.5
+ *   empirically separates legitimate variants (Enrich contacts vs
+ *   accounts: 0.60; Daily vs Weekly standup: 0.68) from structural
+ *   duplicates (identical steps with renamed workflow: 0.75+) with
+ *   headroom on both sides. Revisit weights if tag data lands.
+ *
+ * If a future false-positive case surfaces, add a regression test in
+ * `workflow-tools-dedup.test.ts` → "legitimate variant tolerance" and
+ * re-tune rather than bumping `force: true` everywhere.
+ *
+ * See `features/chat-dedup-variant-tolerance.md`.
+ */
 const WORKFLOW_DEDUP_THRESHOLD = 0.7;
+const WORKFLOW_NAME_WEIGHT = 0.5;
+const WORKFLOW_STEPS_WEIGHT = 0.5;
 
 /**
- * Pull the comparable text out of a workflow definition JSON string:
- * name + each step's name + each step's prompt. Invalid JSON returns "".
+ * Split a workflow into its two comparable text signals: the name alone,
+ * and a concatenation of every step's name + prompt. Callers pass each
+ * signal through `extractKeywords` separately so name-level tokens don't
+ * get drowned out by the much larger step-text bag, and vice versa.
  *
- * Shared by findSimilarWorkflows for the candidate and each existing row.
+ * Malformed definition JSON falls back to `stepsText = ""`.
  */
-function workflowComparableText(name: string, definitionJson: string | null): string {
-  const parts: string[] = [name];
-  if (!definitionJson) return parts.join(" ");
+function workflowSignals(
+  name: string,
+  definitionJson: string | null
+): { nameText: string; stepsText: string } {
+  if (!definitionJson) return { nameText: name, stepsText: "" };
   try {
     const def = JSON.parse(definitionJson);
+    const stepParts: string[] = [];
     if (Array.isArray(def?.steps)) {
       for (const step of def.steps) {
-        if (typeof step?.name === "string") parts.push(step.name);
-        if (typeof step?.prompt === "string") parts.push(step.prompt);
+        if (typeof step?.name === "string") stepParts.push(step.name);
+        if (typeof step?.prompt === "string") stepParts.push(step.prompt);
       }
     }
+    return { nameText: name, stepsText: stepParts.join(" ") };
   } catch {
-    // Malformed JSON — fall back to just the name.
+    return { nameText: name, stepsText: "" };
   }
-  return parts.join(" ");
 }
 
 export interface SimilarWorkflowMatch {
@@ -87,9 +125,9 @@ export async function findSimilarWorkflows(
     .where(eq(workflows.projectId, projectId));
 
   const matches: SimilarWorkflowMatch[] = [];
-  const candidateKeywords = extractKeywords(
-    workflowComparableText(candidateName, candidateDefinitionJson)
-  );
+  const candidateSignals = workflowSignals(candidateName, candidateDefinitionJson);
+  const candidateNameKeywords = extractKeywords(candidateSignals.nameText);
+  const candidateStepKeywords = extractKeywords(candidateSignals.stepsText);
   const candidateNameLower = candidateName.trim().toLowerCase();
 
   for (const row of existing) {
@@ -104,11 +142,14 @@ export async function findSimilarWorkflows(
       continue;
     }
 
-    // Tier 2: Jaccard similarity on keywords
-    const existingKeywords = extractKeywords(
-      workflowComparableText(row.name, row.definition)
-    );
-    const similarity = jaccard(candidateKeywords, existingKeywords);
+    // Tier 2: weighted Jaccard — name and step signals scored separately,
+    // then combined with WORKFLOW_NAME_WEIGHT / WORKFLOW_STEPS_WEIGHT so
+    // target-entity variants (same verb, different noun) are not flagged.
+    const existingSignals = workflowSignals(row.name, row.definition);
+    const nameJ = jaccard(candidateNameKeywords, extractKeywords(existingSignals.nameText));
+    const stepsJ = jaccard(candidateStepKeywords, extractKeywords(existingSignals.stepsText));
+    const similarity =
+      WORKFLOW_NAME_WEIGHT * nameJ + WORKFLOW_STEPS_WEIGHT * stepsJ;
     if (similarity >= WORKFLOW_DEDUP_THRESHOLD) {
       matches.push({
         id: row.id,
@@ -203,7 +244,7 @@ export function workflowTools(ctx: ToolContext) {
           .boolean()
           .optional()
           .describe(
-            "Set to true to bypass the near-duplicate check and always create a new workflow. Only use this when the user has explicitly confirmed they want a second workflow alongside a similar existing one (e.g., 'v2', 'alternate approach'). Default false."
+            "Set to true to bypass the near-duplicate check and always create a new workflow. Only use this when the user has explicitly confirmed they want a second workflow alongside a similar existing one (e.g., 'v2', 'alternate approach'). The dedup check already tolerates target-entity variants (e.g., 'Enrich contacts' vs 'Enrich accounts', 'Daily' vs 'Weekly' standup digest) — so you should NOT pass force=true for those. Default false."
           ),
       },
       async (args) => {