@tpsdev-ai/flair-mcp 0.52.0 → 0.53.0

package/README.md

@@ -44,6 +44,9 @@ Once configured, Claude Code (or any MCP client) gets these tools:
 | `memory_store` | Save a memory with type (lesson/decision/fact) and durability. Optional `usedMemoryIds` cites memories that informed the write. |
 | `memory_get` | Retrieve a specific memory by ID. |
 | `memory_delete` | Delete a memory. |
+| `skill_store` | Write a skill (trigger + procedure) as a skill-tagged memory. |
+| `skill_search` | Find skills that apply to a task. Returns a catalog, not the procedure. |
+| `skill_get` | Retrieve the full skill by ID (disclosure after `skill_search`). |
 | `bootstrap` | Cold-start context — soul + recent memories in one call. |
 | `soul_set` | Set personality or project context (included in every bootstrap). |
 | `soul_get` | Get a personality or project context entry. |

package/dist/adapter-surface.d.ts

@@ -0,0 +1,75 @@
+/**
+ * adapter-surface.ts — the stdio adapter's declared tool set (flair#1575).
+ *
+ * `@tpsdev-ai/flair-mcp` hand-wires each tool via `server.tool(...)` in
+ * index.ts. The native `/mcp` handler ships a separate `TOOLS` registry in
+ * resources/mcp-tools.ts. Those two surfaces drifted: skill_* landed in
+ * TOOLS for 0.52.0 and never reached this package — the surface Claude Code
+ * and Cursor actually use.
+ *
+ * This module is the reviewed chokepoint for that seam:
+ *
+ *   1. `ADAPTER_TOOL_NAMES` is the adapter's declared tool set.
+ *   2. `parseAdapterToolNames` reads the names actually passed to
+ *      `server.tool(...)` in index.ts, so the declaration cannot outrun
+ *      registration (or vice versa).
+ *   3. `STDIO_ADAPTER_EXEMPTIONS` is the explicit, reviewed list of names
+ *      that exist on one surface but not the other. A TOOLS name that is
+ *      neither registered here nor exempted is a CI failure — silent drift
+ *      of the class that hid skill_*.
+ *
+ * Deriving the adapter's handlers from TOOLS (so a new registry tool appears
+ * here for free) is the durable structural fix; it does not fit this chip
+ * because TOOLS is Harper-linked server code and this package talks HTTP via
+ * FlairClient. Detection + exemption list ships now; derive is a follow-on.
+ */
+/** Tools registered on the stdio adapter via `server.tool(...)` in index.ts. */
+export declare const ADAPTER_TOOL_NAMES: readonly ["bootstrap", "flair_orgevent", "flair_workspace_set", "memory_delete", "memory_get", "memory_search", "memory_store", "memory_update", "record_usage", "relationship_store", "skill_get", "skill_search", "skill_store", "soul_get", "soul_set"];
+export type AdapterToolName = (typeof ADAPTER_TOOL_NAMES)[number];
+/**
+ * Reviewed exemptions at the stdio-adapter ↔ server TOOLS seam (flair#1575).
+ *
+ * A name here is a deliberate, reviewed difference — not silent drift.
+ * Adding or removing a name is the control: CI fails if an exemption is
+ * unused (the tool appeared on both sides, or vanished from the side it
+ * was excused on) or if a non-exempt name exists on only one side.
+ */
+export declare const STDIO_ADAPTER_EXEMPTIONS: {
+    /**
+     * Present in resources/mcp-tools.ts `TOOLS`, not wired on the stdio adapter.
+     *
+     * - attention: native /mcp only (flair#677). mcp-tools.ts's module doc
+     *   explicitly does not mirror it into this package.
+     * - memory_basement / memory_restore: archive verbs (flair#1472) landed
+     *   on native /mcp; not yet forwarded over FlairClient.
+     */
+    readonly registryOnly: readonly ["attention", "memory_basement", "memory_restore"];
+    /**
+     * Wired on the stdio adapter, absent from `TOOLS`.
+     *
+     * - relationship_store: the adapter predates the record-types mcp
+     *   declaration. Relationship has no `RECORD_TYPES.mcp` field, so TOOLS
+     *   ships zero relationship_* names. The adapter still exposes the triple
+     *   write (FlairClient.relationship.write).
+     */
+    readonly adapterOnly: readonly ["relationship_store"];
+};
+/**
+ * Collect `server.tool("name", ...)` registrations from adapter source.
+ * Plain string scan — the first string literal argument is the tool name.
+ * Does not use `new RegExp` built from runtime input (CodeQL js/regex-injection).
+ */
+export declare function parseAdapterToolNames(source: string): string[];
+export interface AdapterRegistryParity {
+    /** TOOLS names the adapter neither registers nor exempts. */
+    missingFromAdapter: string[];
+    /** Adapter names that are neither in TOOLS nor adapter-only exempted. */
+    extraOnAdapter: string[];
+    /** Exemption entries that no longer describe a real one-sided difference. */
+    staleExemptions: string[];
+}
+/**
+ * Compare the stdio adapter's tool set to the server TOOLS registry.
+ * Equal after applying the reviewed exemption list — otherwise drift.
+ */
+export declare function adapterRegistryParity(registryNames: readonly string[], adapterNames: readonly string[]): AdapterRegistryParity;

package/dist/adapter-surface.js

@@ -0,0 +1,105 @@
+/**
+ * adapter-surface.ts — the stdio adapter's declared tool set (flair#1575).
+ *
+ * `@tpsdev-ai/flair-mcp` hand-wires each tool via `server.tool(...)` in
+ * index.ts. The native `/mcp` handler ships a separate `TOOLS` registry in
+ * resources/mcp-tools.ts. Those two surfaces drifted: skill_* landed in
+ * TOOLS for 0.52.0 and never reached this package — the surface Claude Code
+ * and Cursor actually use.
+ *
+ * This module is the reviewed chokepoint for that seam:
+ *
+ *   1. `ADAPTER_TOOL_NAMES` is the adapter's declared tool set.
+ *   2. `parseAdapterToolNames` reads the names actually passed to
+ *      `server.tool(...)` in index.ts, so the declaration cannot outrun
+ *      registration (or vice versa).
+ *   3. `STDIO_ADAPTER_EXEMPTIONS` is the explicit, reviewed list of names
+ *      that exist on one surface but not the other. A TOOLS name that is
+ *      neither registered here nor exempted is a CI failure — silent drift
+ *      of the class that hid skill_*.
+ *
+ * Deriving the adapter's handlers from TOOLS (so a new registry tool appears
+ * here for free) is the durable structural fix; it does not fit this chip
+ * because TOOLS is Harper-linked server code and this package talks HTTP via
+ * FlairClient. Detection + exemption list ships now; derive is a follow-on.
+ */
+/** Tools registered on the stdio adapter via `server.tool(...)` in index.ts. */
+export const ADAPTER_TOOL_NAMES = [
+    "bootstrap",
+    "flair_orgevent",
+    "flair_workspace_set",
+    "memory_delete",
+    "memory_get",
+    "memory_search",
+    "memory_store",
+    "memory_update",
+    "record_usage",
+    "relationship_store",
+    "skill_get",
+    "skill_search",
+    "skill_store",
+    "soul_get",
+    "soul_set",
+];
+/**
+ * Reviewed exemptions at the stdio-adapter ↔ server TOOLS seam (flair#1575).
+ *
+ * A name here is a deliberate, reviewed difference — not silent drift.
+ * Adding or removing a name is the control: CI fails if an exemption is
+ * unused (the tool appeared on both sides, or vanished from the side it
+ * was excused on) or if a non-exempt name exists on only one side.
+ */
+export const STDIO_ADAPTER_EXEMPTIONS = {
+    /**
+     * Present in resources/mcp-tools.ts `TOOLS`, not wired on the stdio adapter.
+     *
+     * - attention: native /mcp only (flair#677). mcp-tools.ts's module doc
+     *   explicitly does not mirror it into this package.
+     * - memory_basement / memory_restore: archive verbs (flair#1472) landed
+     *   on native /mcp; not yet forwarded over FlairClient.
+     */
+    registryOnly: ["attention", "memory_basement", "memory_restore"],
+    /**
+     * Wired on the stdio adapter, absent from `TOOLS`.
+     *
+     * - relationship_store: the adapter predates the record-types mcp
+     *   declaration. Relationship has no `RECORD_TYPES.mcp` field, so TOOLS
+     *   ships zero relationship_* names. The adapter still exposes the triple
+     *   write (FlairClient.relationship.write).
+     */
+    adapterOnly: ["relationship_store"],
+};
+/**
+ * Collect `server.tool("name", ...)` registrations from adapter source.
+ * Plain string scan — the first string literal argument is the tool name.
+ * Does not use `new RegExp` built from runtime input (CodeQL js/regex-injection).
+ */
+export function parseAdapterToolNames(source) {
+    const names = [];
+    const re = /server\.tool\(\s*"([a-z][a-z0-9_]*)"/g;
+    let match;
+    while ((match = re.exec(source)) !== null)
+        names.push(match[1]);
+    return names;
+}
+/**
+ * Compare the stdio adapter's tool set to the server TOOLS registry.
+ * Equal after applying the reviewed exemption list — otherwise drift.
+ */
+export function adapterRegistryParity(registryNames, adapterNames) {
+    const registry = new Set(registryNames);
+    const adapter = new Set(adapterNames);
+    const registryOnly = new Set(STDIO_ADAPTER_EXEMPTIONS.registryOnly);
+    const adapterOnly = new Set(STDIO_ADAPTER_EXEMPTIONS.adapterOnly);
+    const missingFromAdapter = [...registry]
+        .filter((name) => !adapter.has(name) && !registryOnly.has(name))
+        .sort();
+    const extraOnAdapter = [...adapter]
+        .filter((name) => !registry.has(name) && !adapterOnly.has(name))
+        .sort();
+    const staleExemptions = [
+        ...[...registryOnly].filter((name) => !registry.has(name) || adapter.has(name)),
+        ...[...adapterOnly].filter((name) => !adapter.has(name) || registry.has(name)),
+    ].sort();
+    return { missingFromAdapter, extraOnAdapter, staleExemptions };
+}

package/dist/index.d.ts

@@ -15,6 +15,9 @@
  *   - flair_workspace_set — write own WorkspaceState (Office Space coordination)
  *   - flair_orgevent      — publish an OrgEvent attributed to self (no forging)
  *   - record_usage        — report that recalled memories were actually used (flair#1147)
+ *   - skill_store         — write a skill-tagged memory (trigger + procedure)
+ *   - skill_search        — catalog skills that apply to a task (not the procedure)
+ *   - skill_get           — retrieve the full skill by id (disclosure after search)
  *
  * Auto-presence (flair#598): every tool call above triggers a fire-and-forget,
  * rate-limited `POST /Presence` heartbeat for the calling agent (see

package/dist/index.js

@@ -15,6 +15,9 @@
  *   - flair_workspace_set — write own WorkspaceState (Office Space coordination)
  *   - flair_orgevent      — publish an OrgEvent attributed to self (no forging)
  *   - record_usage        — report that recalled memories were actually used (flair#1147)
+ *   - skill_store         — write a skill-tagged memory (trigger + procedure)
+ *   - skill_search        — catalog skills that apply to a task (not the procedure)
+ *   - skill_get           — retrieve the full skill by id (disclosure after search)
  *
  * Auto-presence (flair#598): every tool call above triggers a fire-and-forget,
  * rate-limited `POST /Presence` heartbeat for the calling agent (see
@@ -47,6 +50,7 @@ import { deriveActivity, postPresenceSafe, resolveHeartbeatIntervalMs, resolvePr
 import { readEnvOrUnset, stripInterpolationLiteralsFromEnv } from "./env-guard.js";
 import { buildRecordUsageBody, citationIds, withCiteNudge, RECORD_USAGE_ID_MERGE_CONTRACT } from "./usage.js";
 import { serverInfo } from "./version.js";
+import { buildSkillSearchBody, buildSkillStoreBody, formatSkillCatalog, isSkillRecord, projectSkillSearchResponse, stripInternalMemoryFields, } from "./skills.js";
 // ─── Error helpers ──────────────────────────────────────────────────────────
 export function classifyError(err, flairUrl) {
     if (err instanceof FlairError) {
@@ -547,6 +551,110 @@ export async function runMcp() {
             return errorResult(err, flair.url);
         }
     });
+    // ─── Skills as memory (flair#1575 / #1542 / #1546) ──────────────────────────
+    //
+    // Native `/mcp` already ships skill_store / skill_search / skill_get in the
+    // TOOLS registry. This stdio adapter is the surface Claude Code and Cursor
+    // actually use, and it never wired them — 0.52.0's headline was unreachable.
+    // Same pattern as the other tools: shape the HTTP call via FlairClient,
+    // heartbeat, format the result. Write/recall/scope policy stays server-side.
+    server.tool("skill_store", "Write a skill (a reusable capability/procedure) as a skill-tagged memory. " +
+        "The `trigger` text is what the skill embeds from (the recall signal — 'when to use this'), " +
+        "and `content` is the full procedure. Skills are forced durability=persistent and are " +
+        "SkillScan-gated before the embed (a dangerous shell/network payload is rejected).", {
+        content: z.string().describe("The full procedure (markdown body of the SKILL.md)"),
+        trigger: z.string().optional().describe("The 'when to use' text — the recall signal the skill embeds from"),
+        name: z.string().optional().describe("Skill name (SKILL.md frontmatter; stored in metadata)"),
+        description: z.string().optional().describe("Skill description (SKILL.md frontmatter; stored in metadata)"),
+        tags: z.array(z.string()).optional().describe("Additional tags (the 'skill' tag is added automatically)"),
+    }, async ({ content, trigger, name, description, tags }) => {
+        heartbeat();
+        try {
+            const { id, body } = buildSkillStoreBody({
+                agentId: flair.agentId,
+                content,
+                trigger,
+                name,
+                description,
+                tags,
+                claimedClient: flair.claimedClient,
+            });
+            const result = await flair.request("PUT", `/Memory/${id}`, body);
+            const writtenId = typeof result?.id === "string" && result.id.length > 0 ? result.id : id;
+            const preview = content.length > 120 ? content.slice(0, 120) + "..." : content;
+            const lines = [
+                `Skill stored (id: ${writtenId})`,
+                `Preview: ${preview}`,
+                name ? `Name: ${name}` : undefined,
+                trigger ? `Trigger: ${trigger}` : undefined,
+            ].filter((line) => line != null);
+            return {
+                content: [{ type: "text", text: lines.join("\n") }],
+                structuredContent: { id: writtenId, written: true },
+            };
+        }
+        catch (err) {
+            return errorResult(err, flair.url);
+        }
+    });
+    server.tool("skill_search", "Find skills (reusable capabilities/procedures) that apply to a task. " +
+        "Ranks skill-tagged memories by their `trigger` ('when to use') against your task text. " +
+        "Returns a lightweight CATALOG — id, name, trigger, description, tags, agentId — NOT the full " +
+        "procedure (fetch that with skill_get). Scoped to your own + shared skills; another agent's " +
+        "private skill is never returned.", {
+        task: z.string().describe("The task/context to match skills against — natural language; ranked against each skill's trigger"),
+        limit: z.coerce.number().optional().default(5).describe("Max skills to return (default 5)"),
+    }, async ({ task, limit }) => {
+        heartbeat();
+        try {
+            const raw = await flair.request("POST", "/SemanticSearch", buildSkillSearchBody({ task, limit }));
+            const projected = projectSkillSearchResponse(raw);
+            if (!projected || typeof projected !== "object" || !Array.isArray(projected.results)) {
+                return { content: [{ type: "text", text: "No matching skills found." }] };
+            }
+            const results = projected.results;
+            return {
+                content: [{ type: "text", text: formatSkillCatalog(results) }],
+                structuredContent: { results },
+            };
+        }
+        catch (err) {
+            return errorResult(err, flair.url);
+        }
+    });
+    server.tool("skill_get", "Retrieve a full skill by ID — the complete procedure (`content`) plus trigger and metadata. " +
+        "The disclosure step after skill_search's catalog. Read-scoped: you can only get your own or a " +
+        "shared skill, never another agent's private skill. A non-skill id returns not-found.", {
+        id: z.string().describe("Skill (memory) ID"),
+        includeEmbedding: z.coerce.boolean().optional().default(false)
+            .describe("Include the raw embedding vector (large, rarely useful). Default false."),
+    }, async ({ id, includeEmbedding }) => {
+        heartbeat();
+        try {
+            const mem = await flair.memory.get(id);
+            if (!mem || !isSkillRecord(mem)) {
+                return { content: [{ type: "text", text: `Skill ${id} not found.` }] };
+            }
+            const record = includeEmbedding
+                ? mem
+                : stripInternalMemoryFields(mem);
+            const trigger = typeof record.trigger === "string" && record.trigger.length > 0
+                ? record.trigger
+                : "";
+            const text = [
+                record.content,
+                "",
+                `(id: ${record.id}${trigger ? `, trigger: ${trigger}` : ""}, tags: ${Array.isArray(record.tags) ? record.tags.join(", ") : "skill"}, created: ${record.createdAt ?? ""})`,
+            ].join("\n");
+            return {
+                content: [{ type: "text", text }],
+                structuredContent: record,
+            };
+        }
+        catch (err) {
+            return errorResult(err, flair.url);
+        }
+    });
     // ─── Start ───────────────────────────────────────────────────────────────────
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/skills.d.ts

@@ -0,0 +1,49 @@
+/**
+ * skills.ts — stdio-adapter shaping for skill_* tools (flair#1575).
+ *
+ * Native `/mcp` implements skill_store / skill_search / skill_get as thin
+ * wrappers over Memory / SemanticSearch (resources/mcp-tools.ts). This
+ * package talks HTTP via FlairClient, so the wrappers here only shape
+ * the request body and the client-visible result — they re-implement no
+ * write, recall, or scoping logic. Server-side SkillScan, forced
+ * durability=persistent, and resolveReadScope still run on the daemon.
+ *
+ * Progressive disclosure matches the native contract: skill_search returns
+ * catalog cards (never `content` / embedding); skill_get is the disclosure
+ * step for the full procedure.
+ */
+/** The tag that marks a Memory as a skill (resources/skill-write.ts). */
+export declare const SKILL_TAG = "skill";
+export declare function isSkillRecord(record: unknown): boolean;
+/**
+ * Lightweight skill CATALOG card — id/name/trigger/description/tags/agentId.
+ * `name`/`description` live in the opaque metadata JSON blob; a corrupt or
+ * absent blob simply yields no name/desc. `content` and the raw embedding
+ * are deliberately absent (skill_search progressive-disclosure contract).
+ */
+export declare function projectSkillCard(r: unknown): Record<string, unknown>;
+export declare function stripInternalMemoryFields<T extends Record<string, unknown>>(value: T): T;
+/** Body for PUT /Memory/:id — matches native skill_store's Memory.post() shape. */
+export declare function buildSkillStoreBody(opts: {
+    agentId: string;
+    content: string;
+    trigger?: string;
+    name?: string;
+    description?: string;
+    tags?: string[];
+    claimedClient?: string;
+}): {
+    id: string;
+    body: Record<string, unknown>;
+};
+/** SemanticSearch body for skill_search — no agentId (scope is the signed identity). */
+export declare function buildSkillSearchBody(opts: {
+    task: string;
+    limit?: number;
+}): Record<string, unknown>;
+/**
+ * Project a SemanticSearch response onto catalog cards. A guard/error payload
+ * (no `results` array) is returned untouched so the caller can surface it.
+ */
+export declare function projectSkillSearchResponse(res: unknown): unknown;
+export declare function formatSkillCatalog(results: Array<Record<string, unknown>>): string;

package/dist/skills.js

@@ -0,0 +1,119 @@
+/**
+ * skills.ts — stdio-adapter shaping for skill_* tools (flair#1575).
+ *
+ * Native `/mcp` implements skill_store / skill_search / skill_get as thin
+ * wrappers over Memory / SemanticSearch (resources/mcp-tools.ts). This
+ * package talks HTTP via FlairClient, so the wrappers here only shape
+ * the request body and the client-visible result — they re-implement no
+ * write, recall, or scoping logic. Server-side SkillScan, forced
+ * durability=persistent, and resolveReadScope still run on the daemon.
+ *
+ * Progressive disclosure matches the native contract: skill_search returns
+ * catalog cards (never `content` / embedding); skill_get is the disclosure
+ * step for the full procedure.
+ */
+/** The tag that marks a Memory as a skill (resources/skill-write.ts). */
+export const SKILL_TAG = "skill";
+const INTERNAL_MEMORY_FIELDS = ["embedding", "embeddingModel"];
+export function isSkillRecord(record) {
+    const tags = record?.tags;
+    return Array.isArray(tags) && tags.includes(SKILL_TAG);
+}
+/**
+ * Lightweight skill CATALOG card — id/name/trigger/description/tags/agentId.
+ * `name`/`description` live in the opaque metadata JSON blob; a corrupt or
+ * absent blob simply yields no name/desc. `content` and the raw embedding
+ * are deliberately absent (skill_search progressive-disclosure contract).
+ */
+export function projectSkillCard(r) {
+    const row = (r ?? {});
+    let name;
+    let description;
+    if (typeof row.metadata === "string" && row.metadata.length > 0) {
+        try {
+            const meta = JSON.parse(row.metadata);
+            if (meta && typeof meta === "object") {
+                if (typeof meta.name === "string")
+                    name = meta.name;
+                if (typeof meta.description === "string")
+                    description = meta.description;
+            }
+        }
+        catch {
+            /* opaque/corrupt metadata → no name/description on the card */
+        }
+    }
+    return {
+        id: row.id,
+        name,
+        trigger: row.trigger,
+        description,
+        tags: row.tags,
+        agentId: row.agentId,
+    };
+}
+export function stripInternalMemoryFields(value) {
+    const out = { ...value };
+    for (const field of INTERNAL_MEMORY_FIELDS)
+        delete out[field];
+    return out;
+}
+/** Body for PUT /Memory/:id — matches native skill_store's Memory.post() shape. */
+export function buildSkillStoreBody(opts) {
+    const id = `${opts.agentId}-${crypto.randomUUID()}`;
+    const body = {
+        id,
+        agentId: opts.agentId,
+        content: opts.content,
+        tags: [SKILL_TAG, ...(Array.isArray(opts.tags) ? opts.tags : [])],
+    };
+    // durability is NOT set — the server forces persistent for skill-tagged
+    // writes and rejects an explicit ephemeral/session.
+    if (typeof opts.trigger === "string" && opts.trigger.length > 0)
+        body.trigger = opts.trigger;
+    if (opts.claimedClient)
+        body.claimedClient = opts.claimedClient;
+    const meta = {};
+    if (typeof opts.name === "string" && opts.name.length > 0)
+        meta.name = opts.name;
+    if (typeof opts.description === "string" && opts.description.length > 0)
+        meta.description = opts.description;
+    if (Object.keys(meta).length > 0)
+        body.metadata = JSON.stringify(meta);
+    return { id, body };
+}
+/** SemanticSearch body for skill_search — no agentId (scope is the signed identity). */
+export function buildSkillSearchBody(opts) {
+    return {
+        q: opts.task,
+        tag: SKILL_TAG,
+        limit: opts.limit ?? 5,
+        includeMetadata: true,
+        includeTrigger: true,
+    };
+}
+/**
+ * Project a SemanticSearch response onto catalog cards. A guard/error payload
+ * (no `results` array) is returned untouched so the caller can surface it.
+ */
+export function projectSkillSearchResponse(res) {
+    if (!res || typeof res !== "object" || !Array.isArray(res.results)) {
+        return res;
+    }
+    const payload = res;
+    return { ...payload, results: payload.results.map(projectSkillCard) };
+}
+export function formatSkillCatalog(results) {
+    if (results.length === 0)
+        return "No matching skills found.";
+    return results
+        .map((card, i) => {
+        const title = typeof card.name === "string" && card.name.length > 0 ? card.name : "(unnamed skill)";
+        const trigger = typeof card.trigger === "string" && card.trigger.length > 0 ? card.trigger : "";
+        const desc = typeof card.description === "string" && card.description.length > 0 ? card.description : "";
+        const idStr = card.id ? `id:${card.id}` : "";
+        const header = [title, trigger, idStr].filter(Boolean).join(" — ");
+        return desc ? `${i + 1}. ${header}\n   ${desc}` : `${i + 1}. ${header}`;
+    })
+        .join("\n");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tpsdev-ai/flair-mcp",
-  "version": "0.52.0",
+  "version": "0.53.0",
   "description": "MCP server for Flair — persistent memory for Claude Code, Cursor, and any MCP client.",
   "type": "module",
   "main": "dist/index.js",
@@ -28,7 +28,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.27.1",
-    "@tpsdev-ai/flair-client": "0.52.0",
+    "@tpsdev-ai/flair-client": "0.53.0",
     "zod": "4.3.6"
   },
   "license": "Apache-2.0",