@xano/cli 1.2.0 → 1.3.0

package/dist/utils/document-parser.js

@@ -45,6 +45,25 @@ export function parseDocument(content) {
     if (apiGroupMatch) {
         apiGroup = apiGroupMatch[1];
     }
+    // Extract channel if present (e.g., channel = "rooms/{room_id}").
+    // Realtime v2 messages reference their owning channel by PATH, which is what
+    // nests them under it on disk.
+    let channel;
+    const channelMatch = content.match(/^\s*channel\s*=\s*"([^"]*)"/m);
+    if (channelMatch) {
+        channel = channelMatch[1];
+    }
+    // Extract realtime_server if present (e.g., realtime_server = "chat").
+    // Realtime v2 channels/messages reference their owning realtime_server by NAME
+    // via a top-level `realtime_server = "..."`, which is what nests them under it
+    // on disk (mirrors how a message names its channel via `channel = "..."`).
+    // The keyword is `realtime_server` (renamed from a bare `server` to match the
+    // api_group/mcp_server convention — reference the container by its full type).
+    let server;
+    const serverMatch = content.match(/^\s*realtime_server\s*=\s*"([^"]*)"/m);
+    if (serverMatch) {
+        server = serverMatch[1];
+    }
     // Extract canonical if present (e.g., canonical = "abc123")
     let canonical;
     const canonicalMatch = content.match(/canonical\s*=\s*"([^"]*)"/);
@@ -57,7 +76,237 @@ export function parseDocument(content) {
     if (guidMatch) {
         guid = guidMatch[1];
     }
-    return { apiGroup, canonical, content, guid, name, type, verb };
+    return { apiGroup, canonical, channel, content, guid, name, server, type, verb };
+}
+/**
+ * Map a realtime v2 channel path onto directory segments.
+ *
+ * A channel name IS a path template — "rooms/{room_id}" — so the directory tree
+ * mirrors it rather than flattening it. That is the whole reason messages nest
+ * under channels: the tree should show the structure, and
+ * "channel/rooms/[room_id]/post.xs" says immediately that `post` lives on a
+ * parameterized rooms channel.
+ *
+ *   "rooms"                    -> ["rooms"]
+ *   "rooms/{room_id}"          -> ["rooms", "[room_id]"]
+ *   "org/{org_id}/room/{id}"   -> ["org", "[org_id]", "room", "[id]"]
+ *
+ * Braces become brackets because "{" and "}" are awkward in shells, while "["
+ * and "]" are legal on every filesystem. They are still glob character classes,
+ * so scripting against a checkout needs the path quoted.
+ *
+ * Escaping the braces rather than dropping them is what keeps a parameterized
+ * channel distinct from a literal one: without it, "rooms/{room_id}" and a
+ * literal channel named "rooms/room_id" collide on the same directory.
+ *
+ * Mirrors Vfs::channelSegment() on the server.
+ */
+export function channelPathSegments(name, snakeCaseFn) {
+    // A parameter keeps the author's name verbatim so it matches the `input`
+    // block; only the delimiters are swapped.
+    const isParam = /^\{.*\}$/;
+    return name.split('/').map((segment) => (isParam.test(segment) ? `[${segment.slice(1, -1)}]` : snakeCaseFn(segment)));
+}
+/**
+ * Build a map of realtime v2 channel path -> owning realtime_server name.
+ *
+ * This is the cross-document lookup the on-disk nesting needs: a `message`
+ * document names its channel (`channel = "..."`), while a `channel` document
+ * names its server (`realtime_server = "..."`). To place a message under
+ * `realtime/server/<server>/channel/<path>/...` we resolve the message's channel
+ * to that channel's server — which the channel document carries. (Messages now
+ * also carry `realtime_server` directly, but resolving via the channel keeps a
+ * single source of truth for the channel→server mapping.)
+ *
+ * Because every pull path parses the WHOLE multidoc into memory before writing,
+ * we can build this map from the `channel` docs in the same batch (a two-pass
+ * resolve), keyed by the channel's own name (its path). A channel with no
+ * `realtime_server` (e.g. a pre-server export) simply isn't in the map, and
+ * callers fall back accordingly.
+ */
+export function buildChannelServerResolver(documents) {
+    const channelToServer = new Map();
+    for (const doc of documents) {
+        if (doc.type === 'channel' && doc.server) {
+            channelToServer.set(doc.name, doc.server);
+        }
+    }
+    return (channelName) => channelToServer.get(channelName);
+}
+/**
+ * Sanitize a document name for use as a single on-disk filename segment.
+ * Strips quotes and snake_cases the rest. Mirrors the per-command
+ * `sanitizeFilename` the pull commands used to each define privately.
+ */
+export function sanitizeDocumentName(name, snakeCaseFn) {
+    return snakeCaseFn(name.replaceAll('"', ''));
+}
+/**
+ * Resolve where a parsed document lands on disk — the SINGLE source of truth for
+ * the pull layout, shared by every pull command (workspace, tenant, release,
+ * sandbox, ephemeral). Previously each command inlined a ~130-line copy of this
+ * decision; the copies drifted (the realtime v2 realtime_server/channel/message
+ * branches existed only in workspace/tenant), so an ephemeral pull dumped v2
+ * objects into flat top-level channel/, message/ and realtime_server/ folders —
+ * detaching messages from their channels and risking name collisions (message
+ * names are unique only WITHIN a channel).
+ *
+ * @param doc - the parsed document
+ * @param outputDir - the resolved pull output root
+ * @param deps - injected dependencies
+ * @param deps.getApiGroupFolder - resolves an api_group name to its unique folder
+ * @param deps.getChannelServer - resolves a v2 channel path to its owning realtime_server
+ * @param deps.join - the path.join implementation (injectable for testing)
+ * @param deps.snakeCase - the snakeCase implementation the caller uses
+ */
+export function resolveDocumentPath(doc, outputDir, deps) {
+    const { getApiGroupFolder, getChannelServer, join, snakeCase } = deps;
+    const sanitize = (name) => sanitizeDocumentName(name, snakeCase);
+    if (doc.type === 'workspace') {
+        // workspace → workspace/{name}.xs
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'workspace') };
+    }
+    if (doc.type === 'workspace_trigger' || doc.type === 'error_trigger') {
+        // workspace_trigger / error_trigger → workspace/trigger/{name}.xs
+        // (error_trigger is a singleton, colocated with workspace triggers)
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'workspace', 'trigger') };
+    }
+    if (doc.type === 'agent') {
+        // agent → ai/agent/{name}.xs
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'ai', 'agent') };
+    }
+    if (doc.type === 'mcp_server') {
+        // mcp_server → ai/mcp_server/{name}.xs
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'ai', 'mcp_server') };
+    }
+    if (doc.type === 'tool') {
+        // tool → ai/tool/{name}.xs
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'ai', 'tool') };
+    }
+    if (doc.type === 'agent_trigger') {
+        // agent_trigger → ai/agent/trigger/{name}.xs
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'ai', 'agent', 'trigger') };
+    }
+    if (doc.type === 'mcp_server_trigger') {
+        // mcp_server_trigger → ai/mcp_server/trigger/{name}.xs
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'ai', 'mcp_server', 'trigger') };
+    }
+    if (doc.type === 'table_trigger') {
+        // table_trigger → table/trigger/{name}.xs
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'table', 'trigger') };
+    }
+    if (doc.type === 'realtime_channel') {
+        // Realtime v1: realtime_channel → realtime/channel/{name}.xs
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'realtime', 'channel') };
+    }
+    if (doc.type === 'realtime_trigger') {
+        // Realtime v1: realtime_trigger → realtime/trigger/{name}.xs
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'realtime', 'trigger') };
+    }
+    if (doc.type === 'realtime_server_trigger') {
+        // Realtime v2. A realtime_server's connect/disconnect trigger. It references its
+        // owning server by name via `realtime_server = "..."`, so it nests under that
+        // server's folder as `<server>/trigger/`, mirroring how the server's own document
+        // and its channels already nest under realtime/server/<server>/ (DEV-7712). Keeping
+        // it there means every realtime document stays under realtime/ instead of landing at
+        // the output root. A server-less doc (a malformed/legacy export) falls back to a flat
+        // realtime/server_trigger/ under realtime/ rather than the repo root.
+        return {
+            baseName: sanitize(doc.name),
+            typeDir: doc.server
+                ? join(outputDir, 'realtime', 'server', sanitize(doc.server), 'trigger')
+                : join(outputDir, 'realtime', 'server_trigger'),
+        };
+    }
+    if (doc.type === 'channel_trigger') {
+        // Realtime v2. A channel's join/leave/deliver trigger. It references BOTH its owning
+        // server (`realtime_server = "..."`) and its channel (`channel = "..."`), so it nests
+        // beside that channel as `<server>/channel/<channel>/trigger/` — the same path the
+        // channel's own document and messages already use (DEV-7712). Falls back gracefully:
+        // channel but no resolvable server → the legacy flat channel/<path>/trigger/ layout;
+        // neither → realtime/channel_trigger/ under realtime/ (never the output root).
+        if (doc.server && doc.channel) {
+            return {
+                baseName: sanitize(doc.name),
+                typeDir: join(outputDir, 'realtime', 'server', sanitize(doc.server), 'channel', snakeCase(doc.channel), 'trigger'),
+            };
+        }
+        if (doc.channel) {
+            return {
+                baseName: sanitize(doc.name),
+                typeDir: join(outputDir, 'channel', ...channelPathSegments(doc.channel, snakeCase), 'trigger'),
+            };
+        }
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'realtime', 'channel_trigger') };
+    }
+    if (doc.type === 'realtime_server') {
+        // Realtime v2. The realtime_server is the top-level container that owns
+        // channels (which own messages). Its own document is named after itself
+        // inside its name directory, mirroring api_group (api/<group>/<group>.xs).
+        //   realtime_server "chat" → realtime/server/chat/chat.xs
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'realtime', 'server', sanitize(doc.name)) };
+    }
+    if (doc.type === 'channel') {
+        // Realtime v2. The channel owns a directory named after itself (the full
+        // channel name, snake_cased into a single flat segment), and its messages
+        // live in a message/ subfolder inside it. It nests under its owning
+        // realtime_server (from `realtime_server = "..."`):
+        //   channel "rooms/{room_id}" (server "chat")
+        //     → realtime/server/chat/channel/rooms_room_id/rooms_room_id.xs
+        //
+        // A channel with no resolvable server (e.g. a pre-server export) falls back
+        // to the legacy flat channel/<path>/_channel.xs layout.
+        if (doc.server) {
+            return {
+                baseName: snakeCase(doc.name),
+                typeDir: join(outputDir, 'realtime', 'server', sanitize(doc.server), 'channel', snakeCase(doc.name)),
+            };
+        }
+        return { baseName: '_channel', typeDir: join(outputDir, 'channel', ...channelPathSegments(doc.name, snakeCase)) };
+    }
+    if (doc.type === 'message' && doc.channel) {
+        // Realtime v2 message → nests in a message/ subfolder under its channel,
+        // under that channel's server (resolved via the two-pass channel→server map).
+        //   message "post" on channel "rooms/{room_id}" (server "chat")
+        //     → realtime/server/chat/channel/rooms_room_id/message/post.xs
+        //
+        // Nesting matters beyond tidiness: message names are unique only WITHIN a
+        // channel, so a flat message/ directory would collide when two channels
+        // both define e.g. "say". A channel whose server can't be resolved falls
+        // back to the legacy flat channel/ layout.
+        const messageServer = getChannelServer(doc.channel);
+        return {
+            baseName: sanitize(doc.name),
+            typeDir: messageServer
+                ? join(outputDir, 'realtime', 'server', sanitize(messageServer), 'channel', snakeCase(doc.channel), 'message')
+                : join(outputDir, 'channel', ...channelPathSegments(doc.channel, snakeCase)),
+        };
+    }
+    if (doc.type === 'api_group') {
+        // api_group "test" → api/{resolved_folder}/{name}.xs
+        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'api', getApiGroupFolder(doc.name)) };
+    }
+    if (doc.type === 'query' && doc.apiGroup) {
+        // query in group "test" → api/{resolved_folder}/{folders}/{query_name}[_verb].xs
+        const groupFolder = getApiGroupFolder(doc.apiGroup);
+        const nameParts = doc.name.split('/');
+        const leafName = nameParts.pop();
+        const folderParts = nameParts.map((part) => snakeCase(part));
+        const baseName = sanitize(leafName);
+        return {
+            baseName: doc.verb ? `${baseName}_${doc.verb}` : baseName,
+            typeDir: join(outputDir, 'api', groupFolder, ...folderParts),
+        };
+    }
+    // Default: split folder path from name
+    const nameParts = doc.name.split('/');
+    const leafName = nameParts.pop();
+    const folderParts = nameParts.map((part) => snakeCase(part));
+    const baseName = sanitize(leafName);
+    return {
+        baseName: doc.verb ? `${baseName}_${doc.verb}` : baseName,
+        typeDir: join(outputDir, doc.type, ...folderParts),
+    };
 }
 /**
  * Build a unique key for a document based on its type, name, verb, and api_group.
@@ -101,9 +350,7 @@ export function buildApiGroupFolderResolver(documents, snakeCaseFn) {
             apiGroupFolderMap.set(names[i], `${folder}_${i + 1}`);
         }
     }
-    return (groupName) => {
-        return apiGroupFolderMap.get(groupName) ?? snakeCaseFn(groupName);
-    };
+    return (groupName) => apiGroupFolderMap.get(groupName) ?? snakeCaseFn(groupName);
 }
 /**
  * Find local .xs files that contain a specific GUID.
@@ -112,3 +359,63 @@ export function buildApiGroupFolderResolver(documents, snakeCaseFn) {
 export function findFilesWithGuid(entries, guid) {
     return entries.filter((e) => e.content.includes(guid)).map((e) => e.filePath);
 }
+/**
+ * Split a multi-document XanoScript blob (documents joined by `\n---\n`) into
+ * parsed documents, skipping empties and any fragment that fails to parse.
+ *
+ * This is the same split the pull commands apply to the server's multidoc
+ * response. A hand-authored bundle is one file of many `---`-separated
+ * documents; this turns it back into the per-document units every downstream
+ * step (placement, GUID writeback, partial-diff matching) assumes.
+ */
+export function splitMultidoc(blob) {
+    const documents = [];
+    for (const raw of blob.split('\n---\n')) {
+        const trimmed = raw.trim();
+        if (!trimmed)
+            continue;
+        const parsed = parseDocument(trimmed);
+        if (parsed)
+            documents.push(parsed);
+    }
+    return documents;
+}
+/**
+ * Compute where each document lands on disk — a PURE function (no filesystem)
+ * mirroring the split-and-place loop the pull commands run. It resolves each
+ * document via `resolveDocumentPath`, appends `.xs`, and disambiguates
+ * collisions within a directory with a `_N` suffix (the second file named
+ * `say.xs` in a dir becomes `say_2.xs`), exactly as the pull writer does.
+ *
+ * Kept filesystem-free so it can be unit-tested and reused by both the pull
+ * commands and `flatten` without duplicating the placement rules.
+ */
+export function placeDocuments(documents, deps) {
+    const { join, relative, snakeCase } = deps;
+    const getApiGroupFolder = buildApiGroupFolderResolver(documents, snakeCase);
+    const getChannelServer = buildChannelServerResolver(documents);
+    // Per-directory filename counters, so duplicate leaf names get a _N suffix.
+    const filenameCounters = new Map();
+    const placed = [];
+    for (const doc of documents) {
+        const { baseName, typeDir } = resolveDocumentPath(doc, '', {
+            getApiGroupFolder,
+            getChannelServer,
+            join,
+            snakeCase,
+        });
+        const dirKey = typeDir;
+        if (!filenameCounters.has(dirKey))
+            filenameCounters.set(dirKey, new Map());
+        const typeCounters = filenameCounters.get(dirKey);
+        const count = typeCounters.get(baseName) || 0;
+        typeCounters.set(baseName, count + 1);
+        const filename = count === 0 ? `${baseName}.xs` : `${baseName}_${count + 1}.xs`;
+        const abs = join(typeDir, filename);
+        // typeDir was built off an empty root, so `abs` is already root-relative;
+        // normalize any leading separator via relative() for a clean POSIX path.
+        const relPath = relative('', abs);
+        placed.push({ content: doc.content, relPath });
+    }
+    return placed;
+}

package/dist/utils/flatten.d.ts

@@ -0,0 +1,36 @@
+/** Outcome of flattening one bundle file. */
+export interface FlattenResult {
+    /** True when the original bundle was removed. */
+    removedSource: boolean;
+    /** Why the file was skipped, if it was (empty / single-document). */
+    skipped?: 'empty' | 'single';
+    /** Absolute paths written (or that would be written, in dry-run). */
+    written: string[];
+}
+export interface FlattenOptions {
+    /** Preview only — compute the plan and write nothing, delete nothing. */
+    dryRun?: boolean;
+    /** Overwrite existing destination files instead of throwing on a clash. */
+    force?: boolean;
+    /** Keep the original bundle file (default: delete after a successful split). */
+    keepSource?: boolean;
+    /** Optional line logger (e.g. command.log) for a per-file plan. */
+    log?: (msg: string) => void;
+    /** Output root (default: the bundle file's own directory). */
+    outputDir?: string;
+}
+/**
+ * Split ONE multi-document `.xs` bundle (documents joined by `---`) into the
+ * standard per-document tree — the exact layout `pull` produces — using the
+ * shared `placeDocuments` placement so the two never drift.
+ *
+ * Filesystem-touching, but self-contained: it reads the bundle, resolves every
+ * document's destination, checks for collisions, writes, and (unless
+ * `keepSource`) removes the original. Throws on a destination collision when
+ * `force` is not set, and never deletes the source when a written document
+ * landed on the source's own path.
+ *
+ * Shared by the `flatten` command and the push-time prompt, so a user who
+ * confirms "flatten now?" gets byte-identical output to running `xano flatten`.
+ */
+export declare function flattenBundleFile(bundleFile: string, opts?: FlattenOptions): FlattenResult;

package/dist/utils/flatten.js

@@ -0,0 +1,68 @@
+import snakeCase from 'lodash.snakecase';
+import * as fs from 'node:fs';
+import { basename, dirname, join, relative, resolve } from 'node:path';
+import { placeDocuments, splitMultidoc } from './document-parser.js';
+/**
+ * Split ONE multi-document `.xs` bundle (documents joined by `---`) into the
+ * standard per-document tree — the exact layout `pull` produces — using the
+ * shared `placeDocuments` placement so the two never drift.
+ *
+ * Filesystem-touching, but self-contained: it reads the bundle, resolves every
+ * document's destination, checks for collisions, writes, and (unless
+ * `keepSource`) removes the original. Throws on a destination collision when
+ * `force` is not set, and never deletes the source when a written document
+ * landed on the source's own path.
+ *
+ * Shared by the `flatten` command and the push-time prompt, so a user who
+ * confirms "flatten now?" gets byte-identical output to running `xano flatten`.
+ */
+export function flattenBundleFile(bundleFile, opts = {}) {
+    const { dryRun = false, force = false, keepSource = false, log } = opts;
+    const content = fs.readFileSync(bundleFile, 'utf8').trim();
+    const documents = splitMultidoc(content);
+    if (documents.length === 0)
+        return { removedSource: false, skipped: 'empty', written: [] };
+    if (documents.length === 1)
+        return { removedSource: false, skipped: 'single', written: [] };
+    const outputDir = opts.outputDir ? resolve(opts.outputDir) : dirname(bundleFile);
+    const placed = placeDocuments(documents, { join, relative, snakeCase });
+    // Pre-check destination collisions (unless --force / dry-run). A written file
+    // landing on the source's own path is not a clash — it replaces the bundle.
+    if (!dryRun && !force) {
+        const clashes = placed
+            .map((p) => join(outputDir, p.relPath))
+            .filter((abs) => fs.existsSync(abs) && resolve(abs) !== resolve(bundleFile));
+        if (clashes.length > 0) {
+            throw new Error(`Destination file(s) already exist (use --force to overwrite):\n` +
+                clashes.map((c) => `    ${relative(process.cwd(), c) || c}`).join('\n'));
+        }
+    }
+    const written = [];
+    for (const p of placed) {
+        const abs = join(outputDir, p.relPath);
+        if (log)
+            log(`  WRITE  ${relative(process.cwd(), abs) || p.relPath}`);
+        if (!dryRun) {
+            fs.mkdirSync(dirname(abs), { recursive: true });
+            fs.writeFileSync(abs, p.content.endsWith('\n') ? p.content : `${p.content}\n`, 'utf8');
+        }
+        written.push(abs);
+    }
+    // Remove the original bundle unless asked to keep it, and never when a split
+    // document was written over the source's own path.
+    let removedSource = false;
+    if (!dryRun && !keepSource) {
+        const wroteOverSource = placed.some((p) => resolve(join(outputDir, p.relPath)) === resolve(bundleFile));
+        if (wroteOverSource) {
+            if (log)
+                log(`  (source ${basename(bundleFile)} was overwritten by a split document; not deleting)`);
+        }
+        else {
+            fs.rmSync(bundleFile);
+            removedSource = true;
+            if (log)
+                log(`  removed ${relative(process.cwd(), bundleFile) || bundleFile}`);
+        }
+    }
+    return { removedSource, written };
+}

package/dist/utils/knowledge-sync.d.ts

@@ -17,6 +17,7 @@ export interface KnowledgeObject {
     mode?: string;
     name: string;
     scope?: string;
+    tag?: string[];
 }
 /** A locally-collected object that also remembers its primary file on disk (for GUID writeback). */
 export interface LocalKnowledgeObject extends KnowledgeObject {

package/dist/utils/knowledge-sync.js

@@ -1,4 +1,3 @@
-/* eslint-disable camelcase -- knowledge_type / dry_run / guid_map are external Metadata API field names */
 import * as yaml from 'js-yaml';
 import snakeCase from 'lodash.snakecase';
 import { minimatch } from 'minimatch';
@@ -12,7 +11,7 @@ import { dirname, join, relative, sep } from 'node:path';
 // let the server dictate file paths.
 export const KNOWLEDGE_DIR = 'knowledge';
 // ── Frontmatter ──────────────────────────────────────────────────────────────
-const FRONTMATTER_ORDER = ['name', 'description', 'knowledge_type', 'scope', 'inclusion', 'enabled', 'guid'];
+const FRONTMATTER_ORDER = ['name', 'description', 'knowledge_type', 'inclusion', 'tags', 'guid'];
 /**
  * Build a primary `.md` file body: YAML frontmatter (built from the object's
  * structured fields) followed by the markdown content.
@@ -23,12 +22,10 @@ export function buildPrimaryContent(obj) {
     if (obj.description !== undefined)
         meta.description = obj.description;
     meta.knowledge_type = obj.knowledge_type;
-    if (obj.scope !== undefined)
-        meta.scope = obj.scope;
     if (obj.mode !== undefined)
         meta.inclusion = modeToInclusion(obj.mode);
-    if (obj.enabled !== undefined)
-        meta.enabled = obj.enabled;
+    if (obj.tag !== undefined && obj.tag.length > 0)
+        meta.tags = obj.tag;
     if (obj.guid !== undefined)
         meta.guid = obj.guid;
     // Emit keys in a stable, human-friendly order.
@@ -107,6 +104,10 @@ const MODE_TO_INCLUSION = {
 function modeToInclusion(mode) {
     return MODE_TO_INCLUSION[mode] ?? mode;
 }
+/** Parse the on-disk `tags:` frontmatter value into a string array, or `undefined` if absent/malformed. */
+function parseTags(tags) {
+    return Array.isArray(tags) && tags.every((t) => typeof t === 'string') ? tags : undefined;
+}
 // ── Path mapping (CLI-owned layout) ────────────────────────────────────────────
 /**
  * Allocate a unique snake_case folder/file segment per call, suffixing
@@ -246,6 +247,9 @@ export function collectKnowledgeObjects(inputDir, include, exclude) {
         };
         if (typeof meta.guid === 'string')
             obj.guid = meta.guid;
+        const tags = parseTags(meta.tags);
+        if (tags)
+            obj.tag = tags;
         if (knowledgeType === 'skill') {
             const skillFolder = posixPath.slice('skills/'.length, posixPath.indexOf('/SKILL.md'));
             const refPrefix = `skills/${skillFolder}/references/`;
@@ -345,6 +349,7 @@ function canonical(obj) {
         files,
         mode: obj.mode ?? '',
         scope: obj.scope ?? '',
+        tag: [...(obj.tag ?? [])].sort(),
     });
 }
 /**

package/dist/utils/microservice-wait.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Poll a tenant's microservice deployment status until every auto-deployed
+ * microservice settles (ok/error) or a timeout elapses. Backs `ephemeral push
+ * --wait`: after a multidoc push auto-deploys microservices (tenant_deploy=
+ * "auto"), the CLI waits here for them to become Ready and reports the outcome.
+ *
+ * The backend route (GET .../tenant/{name}/microservice, statement
+ * mvp:microservice_status_all) returns one entry per microservice with a live
+ * k8s readiness read. `manual`/`disabled` microservices are reported but not
+ * waited on (they were never deployed by the push).
+ */
+/** One microservice's status as returned by the tenant status route. */
+export interface MicroserviceStatusEntry {
+    desired?: number;
+    detail?: string;
+    microservice_id: number;
+    name: string;
+    ready?: number;
+    status: string;
+    tenant_deploy?: string;
+}
+export interface WaitOptions {
+    /** Bearer token for the authed status GET. */
+    accessToken: string;
+    /** Called once per poll with the latest entries, for progress rendering. */
+    onPoll?: (entries: MicroserviceStatusEntry[], elapsedMs: number) => void;
+    /** Poll cadence in ms (default 2000). */
+    pollIntervalMs?: number;
+    /** Absolute URL of the tenant microservice status route. */
+    statusUrl: string;
+    /** Overall wait budget in ms (default 300000 = 300s). */
+    timeoutMs?: number;
+    /** Verbose request logging passthrough. */
+    verbose?: boolean;
+    /** Authed fetch (command.verboseFetch bound), so TLS/dispatcher settings apply. */
+    verboseFetch: (url: string, options: RequestInit, verbose: boolean, authToken?: string) => Promise<Response>;
+}
+export interface WaitResult {
+    /** The final status entries observed. */
+    entries: MicroserviceStatusEntry[];
+    /** True if any awaited (auto) microservice ended in "error". */
+    hadError: boolean;
+    /** True if the wait budget elapsed before all awaited microservices settled. */
+    timedOut: boolean;
+}
+/** An awaited microservice is one that was auto-deployed and is not skipped/disabled. */
+export declare function isAwaited(entry: MicroserviceStatusEntry): boolean;
+/**
+ * Poll until all awaited microservices settle or the timeout elapses. Transient
+ * poll failures (network blips, a brief 5xx while a pod restarts) are tolerated —
+ * they don't abort the wait; only the overall timeout does.
+ */
+export declare function waitForMicroservices(opts: WaitOptions): Promise<WaitResult>;

package/dist/utils/microservice-wait.js

@@ -0,0 +1,84 @@
+/**
+ * Poll a tenant's microservice deployment status until every auto-deployed
+ * microservice settles (ok/error) or a timeout elapses. Backs `ephemeral push
+ * --wait`: after a multidoc push auto-deploys microservices (tenant_deploy=
+ * "auto"), the CLI waits here for them to become Ready and reports the outcome.
+ *
+ * The backend route (GET .../tenant/{name}/microservice, statement
+ * mvp:microservice_status_all) returns one entry per microservice with a live
+ * k8s readiness read. `manual`/`disabled` microservices are reported but not
+ * waited on (they were never deployed by the push).
+ */
+/** Statuses that mean an awaited microservice has settled (no longer in flight). */
+const SETTLED = new Set(['error', 'ok']);
+/** Statuses that mean we don't wait on this microservice at all. */
+const NOT_AWAITED = new Set(['disabled', 'skipped']);
+const sleep = (ms) => new Promise((r) => {
+    setTimeout(r, ms);
+});
+/** An awaited microservice is one that was auto-deployed and is not skipped/disabled. */
+export function isAwaited(entry) {
+    return !NOT_AWAITED.has(entry.status) && (entry.tenant_deploy ?? 'auto') !== 'manual';
+}
+/** True once every awaited microservice has settled (ok/error). */
+function allSettled(entries) {
+    const awaited = entries.filter((e) => isAwaited(e));
+    // No auto microservices at all → nothing to wait for.
+    if (awaited.length === 0)
+        return true;
+    return awaited.every((e) => SETTLED.has(e.status));
+}
+/**
+ * Fetch the status route once. Throws on a non-2xx so the caller can decide
+ * whether a transient failure is fatal (it isn't — we keep polling).
+ */
+async function fetchStatus(opts) {
+    const res = await opts.verboseFetch(opts.statusUrl, { headers: { Authorization: `Bearer ${opts.accessToken}` }, method: 'GET' }, opts.verbose ?? false, opts.accessToken);
+    if (!res.ok) {
+        throw new Error(`status ${res.status} ${res.statusText}`);
+    }
+    const body = (await res.json());
+    if (!Array.isArray(body)) {
+        throw new TypeError('unexpected status response shape');
+    }
+    return body;
+}
+/**
+ * Poll until all awaited microservices settle or the timeout elapses. Transient
+ * poll failures (network blips, a brief 5xx while a pod restarts) are tolerated —
+ * they don't abort the wait; only the overall timeout does.
+ */
+export async function waitForMicroservices(opts) {
+    const pollIntervalMs = opts.pollIntervalMs ?? 2000;
+    const timeoutMs = opts.timeoutMs ?? 300_000;
+    const start = Date.now();
+    let entries = [];
+    // Poll loop. We always do at least one fetch so `--wait` reports even when the
+    // deployment already settled between the push returning and the first poll.
+    for (;;) {
+        const elapsed = Date.now() - start;
+        try {
+            // eslint-disable-next-line no-await-in-loop -- polling is sequential by design
+            entries = await fetchStatus(opts);
+            opts.onPoll?.(entries, elapsed);
+            if (allSettled(entries)) {
+                return { entries, hadError: entries.some((e) => isAwaited(e) && e.status === 'error'), timedOut: false };
+            }
+        }
+        catch {
+            // A transient status read failure is non-fatal — keep polling until the
+            // overall timeout. There is deliberately no consecutive-failure cap: we
+            // don't surface each blip, and the timeout is the only failure signal.
+        }
+        if (Date.now() - start + pollIntervalMs > timeoutMs) {
+            // Out of budget. Report whatever we last saw as timed out.
+            return {
+                entries,
+                hadError: entries.some((e) => isAwaited(e) && e.status === 'error'),
+                timedOut: true,
+            };
+        }
+        // eslint-disable-next-line no-await-in-loop -- pacing the poll loop is the point
+        await sleep(pollIntervalMs);
+    }
+}