@aiwg/cli 2026.9.12 → 2026.9.16

package/dist/src/sessions/fortemi-shard-recovery.js

@@ -0,0 +1,151 @@
+/**
+ * Recovers an `AiwgFortemiIndexExport`-shaped record graph from a real
+ * `full-v1`/`2.0.0` Knowledge Shard archive built by
+ * `aiwgFortemiIndexToKnowledgeShardWithReport` (#2564).
+ *
+ * `@fortemi/core`'s own `aiwgFortemiIndexFromKnowledgeShard` only recovers
+ * archives built by the plain `aiwgFortemiIndexToKnowledgeShard` (`core-v1`):
+ * that function embeds the entire original record verbatim as opaque note
+ * metadata (`metadata.aiwg_fortemi_index`), which is what its reader looks
+ * for. The strict `full-v1` converter deliberately does not do this -- the
+ * point of `full-v1` is a genuinely native note/tag/link/provenance
+ * representation any Fortemi consumer can read, not an AIWG-only escape
+ * hatch. Verified empirically: `aiwgFortemiIndexFromKnowledgeShard` throws
+ * "has no AIWG index metadata" against a `full-v1` archive, and even AIWG's
+ * own artifact-index shard export test only round-trips through it using
+ * `profile: "core-v1"`.
+ *
+ * So recovering a `full-v1` archive means reading the native shard files
+ * directly and inverting this module's own mapping:
+ *   - id/type/source/privacy  <- note.metadata.aiwg_source
+ *   - title/text              <- note.title / note.original_content
+ *   - tags                    <- note.tags
+ *   - relationships           <- links.jsonl (from_note_id/to_note_id/kind/score)
+ *   - provenance/provenance_events <- provenance_activities.jsonl, split by
+ *     the `source:<field>` activity_type convention this module uses to
+ *     distinguish `provenance` entries from `provenance_events` entries
+ *
+ * The index-level wrapper (`AiwgFortemiIndexExport.source`/`compatibility`)
+ * is genuinely not preserved anywhere in a full-v1 archive -- there is no
+ * per-archive metadata sidecar for it, only per-note. Recovery reports this
+ * honestly with a fixed placeholder rather than inventing a value.
+ */
+import { unpackTarGz } from '@fortemi/core';
+import { EXPORT_MANIFEST_RECORD_TYPE, SESSION_EXPORT_INDEX_SCHEMA_VERSION, SESSION_EXPORT_RECORD_SCHEMA_VERSION, } from './fortemi-export-mapping.js';
+const SOURCE_PROVENANCE_PREFIX = 'source:';
+function decodeJsonLines(bytes) {
+    if (!bytes)
+        return [];
+    const text = new TextDecoder().decode(bytes);
+    return text.split('\n').filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
+}
+function isAiwgSourceSidecar(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const candidate = value;
+    return typeof candidate.record_id === 'string' && typeof candidate.record_type === 'string';
+}
+export class FortemiShardRecoveryError extends Error {
+}
+/**
+ * Recovers the record graph from a `full-v1` archive. Throws
+ * `FortemiShardRecoveryError` if the archive has no notes, or any note is
+ * missing the `aiwg_source` sidecar this module's own mapping always writes
+ * (meaning the shard wasn't produced by this mapping and can't be recovered
+ * this way).
+ */
+export function recoverAiwgFortemiIndexFromFullV1Shard(bytes) {
+    const files = unpackTarGz(bytes);
+    const notes = decodeJsonLines(files.get('notes.jsonl'));
+    if (notes.length === 0) {
+        throw new FortemiShardRecoveryError('Knowledge Shard contains no notes to recover');
+    }
+    const links = decodeJsonLines(files.get('links.jsonl'));
+    const activities = decodeJsonLines(files.get('provenance_activities.jsonl'));
+    const noteIdToRecordId = new Map();
+    for (const note of notes) {
+        const sidecar = note.metadata?.aiwg_source;
+        if (!isAiwgSourceSidecar(sidecar)) {
+            throw new FortemiShardRecoveryError(`Knowledge Shard note ${note.id} has no aiwg_source metadata -- `
+                + 'this archive was not produced by the AIWG session export mapping');
+        }
+        noteIdToRecordId.set(note.id, sidecar.record_id);
+    }
+    const items = notes.map((note) => {
+        const sidecar = note.metadata.aiwg_source;
+        const relationships = links
+            .filter((link) => link.from_note_id === note.id)
+            .map((link) => ({
+            type: link.kind,
+            target_id: link.to_note_id ? (noteIdToRecordId.get(link.to_note_id) ?? link.to_note_id) : '',
+            confidence: link.score ?? undefined,
+        }));
+        const noteActivities = activities.filter((activity) => activity.note_id === note.id);
+        const provenance = [];
+        const provenanceEvents = [];
+        for (const activity of noteActivities) {
+            const metadata = activity.metadata ?? {};
+            if (activity.activity_type.startsWith(SOURCE_PROVENANCE_PREFIX)) {
+                provenance.push({
+                    field: activity.activity_type.slice(SOURCE_PROVENANCE_PREFIX.length),
+                    source: metadata.source ?? activity.model_name ?? '',
+                    path: metadata.path ?? '',
+                    confidence: metadata.confidence ?? 'source',
+                    privacy: metadata.privacy ?? 'private',
+                });
+            }
+            else {
+                provenanceEvents.push({
+                    activity: activity.activity_type,
+                    agent: activity.model_name ?? undefined,
+                    started_at: activity.started_at ?? undefined,
+                    ended_at: activity.ended_at ?? undefined,
+                    source: metadata.source ?? undefined,
+                    path: metadata.path ?? undefined,
+                    confidence: metadata.confidence ?? undefined,
+                    privacy: metadata.privacy ?? undefined,
+                    attributes: metadata.attributes ?? undefined,
+                });
+            }
+        }
+        return {
+            schema_version: SESSION_EXPORT_RECORD_SCHEMA_VERSION,
+            id: sidecar.record_id,
+            type: sidecar.record_type,
+            source: sidecar.source,
+            title: note.title,
+            text: note.original_content,
+            facets: {},
+            tags: note.tags,
+            concepts: [],
+            relationships,
+            provenance,
+            provenance_events: provenanceEvents,
+            privacy: sidecar.privacy,
+            updated_at: sidecar.source.updated_at ?? new Date(0).toISOString(),
+        };
+    });
+    items.sort((left, right) => left.id.localeCompare(right.id));
+    // The export-manifest record (see fortemi-export-mapping.ts) carries the
+    // index-level wrapper fields through the same provenance_events mechanism
+    // as everything else. Extract it and exclude it from the recovered items
+    // -- it isn't a session, event, or output record.
+    const manifestIndex = items.findIndex((item) => item.type === EXPORT_MANIFEST_RECORD_TYPE);
+    const manifestAttributes = manifestIndex >= 0
+        ? items[manifestIndex].provenance_events?.[0]?.attributes
+        : undefined;
+    const recoveredItems = manifestIndex >= 0
+        ? items.filter((_, index) => index !== manifestIndex)
+        : items;
+    return {
+        schema_version: SESSION_EXPORT_INDEX_SCHEMA_VERSION,
+        generated_at: manifestAttributes?.generatedAt ?? new Date(0).toISOString(),
+        source: manifestAttributes
+            ? { repo: manifestAttributes.repo ?? 'unknown', privacy: manifestAttributes.privacy ?? 'private' }
+            // No manifest record present (e.g. an archive built before this record
+            // existed) -- labeled honestly rather than invented.
+            : { repo: 'recovered-from-full-v1-shard', privacy: 'private' },
+        items: recoveredItems,
+    };
+}
+//# sourceMappingURL=fortemi-shard-recovery.js.map

package/dist/src/sessions/index.js

@@ -7,6 +7,11 @@ export * from './repository.js';
 export * from './ports.js';
 export * from './optional-backends.js';
 export * from './knowledge-shard.js';
+export * from './fortemi-export-mapping.js';
+export * from './fortemi-shard-recovery.js';
+export * from './fortemi-shard-blobs.js';
+export * from './output-lineage.js';
+export * from './export-plan.js';
 export * from './candidates.js';
 export * from './promotion.js';
 export * from './output-registration.js';
@@ -28,6 +33,7 @@ export * from './adapters/hermes.js';
 export * from './adapters/opencode.js';
 export * from './adapters/openclaw.js';
 export * from './adapters/openhuman.js';
+export * from './adapters/grokbot.js';
 export * from './adapters/pi.js';
 export * from './adapters/deepseek-harness.js';
 export * from './adapters/warp.js';

package/dist/src/sessions/output-lineage.js

@@ -0,0 +1,43 @@
+import { sessionRecordLocator } from './fortemi-export-mapping.js';
+/** Known, exact conventions a `kind: 'session'` source ref may use to name a session. Order is the preference used to report `matchReason`. */
+function sessionRefCandidates(session) {
+    return [
+        { ref: session.sessionId, reason: 'ref equals the stable session id' },
+        { ref: `session:${session.sessionId}`, reason: "ref equals 'session:<stable session id>'" },
+        { ref: sessionRecordLocator(session), reason: 'ref equals the aiwg-session:// export locator' },
+        { ref: session.nativeSessionId, reason: 'ref equals the native session id' },
+        { ref: `session:${session.nativeSessionId}`, reason: "ref equals 'session:<native session id>'" },
+    ];
+}
+function matchSource(source, session) {
+    if (source.kind !== 'session')
+        return null;
+    for (const candidate of sessionRefCandidates(session)) {
+        if (source.ref === candidate.ref)
+            return candidate.reason;
+    }
+    return null;
+}
+/**
+ * Registrations are scanned once and matched against every selected session
+ * -- bounded by the selection, not an unbounded corpus walk, satisfying
+ * "bound any file discovery to an explicit workspace/source scope."
+ */
+export function discoverSessionOutputCandidates(registrations, sessions) {
+    const candidates = [];
+    for (const registration of registrations) {
+        for (const session of sessions) {
+            for (const source of registration.contextPack.sources) {
+                const reason = matchSource(source, session);
+                if (reason) {
+                    candidates.push({
+                        registration, sessionId: session.sessionId, lineage: 'registered', matchReason: reason,
+                    });
+                    break;
+                }
+            }
+        }
+    }
+    return candidates;
+}
+//# sourceMappingURL=output-lineage.js.map

package/dist/src/sessions/workspace-discovery.js

@@ -16,7 +16,7 @@ import { redactSourceLocator } from './discovery.js';
 import { fingerprintSourceFile } from './readers.js';
 export const DISCOVERY_MANIFEST_VERSION = '1.0.0';
 const MANUAL_EXPORT_PROVIDERS = new Set([
-    'copilot', 'hermes', 'opencode', 'openclaw', 'openhuman',
+    'copilot', 'hermes', 'opencode', 'openclaw', 'openhuman', 'grokbot',
     'warp', 'devin-desktop', 'generic',
 ]);
 export async function discoverWorkspaceHistories(options) {

package/dist/src/skills/deployer.js

@@ -16,6 +16,7 @@ import { AGENT_SKILLS_SIDECAR_SCHEMA, AIWG_SKILL_CONTROL_FIELDS, createAgentSkil
 import { getImportedAgentSkill } from './importer.js';
 import { validateAgentSkillContent } from './validator.js';
 import { resolveHermesHomePath } from '../providers/hermes-home.js';
+import { GROKBOT_SKILLS_DIR_ENV, grokbotMissingRootRemediation, resolveGrokbotSkillsDir, } from '../providers/grokbot-paths.js';
 export const AGENT_SKILL_MANAGED_MARKER = '.aiwg-managed';
 export const AGENT_SKILL_DEPLOYMENT_SIDECAR = '.aiwg-agent-skill.json';
 const MARKER_CONTENT = 'aiwg-agent-skill-v1\n';
@@ -78,6 +79,22 @@ function resolvePolicy(target, options) {
             appendToDescription = namespace.appendToDescription;
             reasons.push('applies the Factory description guidance before strict validation');
             break;
+        case 'grokbot': {
+            // Fail closed: never invent ~/grokbot-skills or ~/.grokbot.
+            const configured = resolveGrokbotSkillsDir(process.env);
+            if (!configured) {
+                root = '';
+                status = 'unsupported';
+                supported = false;
+                reasons.push(grokbotMissingRootRemediation(process.env));
+                warnings.push(`Agent Skills deploy for grokbot requires absolute ${GROKBOT_SKILLS_DIR_ENV}; no filesystem root was invented`);
+            }
+            else {
+                root = configured;
+                reasons.push(`uses the operator-configured ${GROKBOT_SKILLS_DIR_ENV} skills root with strict managed ownership markers`);
+            }
+            break;
+        }
         case 'hermes':
             if (options.homeDir === undefined) {
                 root = resolveHermesHomePath('skills');

package/dist/src/smiths/skillsmith/collision-detector.js

@@ -36,6 +36,7 @@ const PLATFORM_BUILTINS = {
     'opencode': ['help', 'run'],
     'warp': ['help', 'settings'],
     'hermes': [],
+    'grokbot': [],
     'openclaw': [],
     'openhuman': [],
     'factory': [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwg/cli",
-  "version": "2026.9.12",
+  "version": "2026.9.16",
   "description": "Lightweight AIWG CLI for signed, versioned web-backed resources.",
   "type": "module",
   "license": "MIT",

package/tools/agents/deploy-agents.mjs

@@ -20,7 +20,7 @@
  *   --rules-only             Deploy only rules (skip agents)
  *   --dry-run                Show what would be deployed without writing
  *   --force                  Overwrite existing files
- *   --provider <name>        Target provider: antigravity (agy), claude (default), openai, codex, cursor, opencode, copilot, factory, pi, omp, deepseek-harness (dsh), warp, devin, hermes, or openclaw
+ *   --provider <name>        Target provider: antigravity (agy), claude (default), openai, codex, cursor, opencode, copilot, factory, grokbot, pi, omp, deepseek-harness (dsh), warp, devin, hermes, openhuman, or openclaw
  *   --model <name>            Override model for all tiers (blanket)
  *   --reasoning-model <name> Override model for reasoning tasks
  *   --coding-model <name>    Override model for coding tasks
@@ -123,7 +123,7 @@ const PROVIDER_ALIASES = {
   'dsh': 'deepseek-harness',
 };
 
-const AVAILABLE_PROVIDERS = ['antigravity', 'claude', 'factory', 'codex', 'opencode', 'copilot', 'cursor', 'pi', 'omp', 'deepseek-harness', 'warp', 'windsurf', 'hermes', 'openclaw', 'openhuman'];
+const AVAILABLE_PROVIDERS = ['antigravity', 'claude', 'factory', 'codex', 'opencode', 'copilot', 'cursor', 'pi', 'omp', 'deepseek-harness', 'warp', 'windsurf', 'hermes', 'openclaw', 'openhuman', 'grokbot'];
 
 const UNSUPPORTED_PROVIDER_HINTS = {
   'devin-cli': [
@@ -651,6 +651,7 @@ Providers (all deploy agents, commands, skills, and rules):
               Paths: AGENTS.md, .agents/skills/, .dsh/aiwg.cordis.patch.yml
   devin     - Devin Desktop (preferred; aliases: devin-desktop, windsurf)
               Paths: .windsurf/agents/, .windsurf/workflows/, .windsurf/skills/, .windsurf/rules/
+  grokbot   - Grok Bot (experimental; AGENTS.md bridge; skills only with AIWG_GROKBOT_SKILLS_DIR)
   hermes    - Hermes Agent (MCP-based integration)
               Skills: $HERMES_HOME/skills/ (user-global; defaults to ~/.hermes/skills/) | Agents: AGENTS.md
               Commands/Rules: served via MCP, not file-deployed

package/tools/agents/providers/grokbot.mjs

@@ -0,0 +1,285 @@
+/**
+ * Grok Bot provider (experimental).
+ *
+ * Discover-first project bridge + fail-closed user skill root.
+ * Never targets `.cursor/**` or invents `~/.grokbot`.
+ *
+ * User-scope skill writes require AIWG_GROKBOT_SKILLS_DIR (absolute path).
+ * See `docs/architecture/adr-grokbot-provider-target.md` and #203–#208.
+ */
+
+import path from 'path';
+import os from 'os';
+import {
+  collectFrameworkArtifacts,
+  createAgentsMdFromTemplate,
+  deploySkillsWithKernelRouting,
+  getAddonSkillDirs,
+  normalizeDeploymentMode,
+  resolveAiwgRoot,
+} from './base.mjs';
+
+export const name = 'grokbot';
+export const aliases = [];
+
+const SKILLS_DIR_ENV = 'AIWG_GROKBOT_SKILLS_DIR';
+
+/**
+ * Resolve configured Grok Bot skills directory (fail-closed).
+ * Mirrors src/providers/grokbot-paths.ts for the JS deploy path.
+ */
+export function resolveGrokbotSkillsDir(env = process.env, userHome = os.homedir()) {
+  const raw = (env[SKILLS_DIR_ENV] || '').trim();
+  if (!raw) return null;
+  let expanded = raw;
+  if (raw === '~') return null;
+  if (raw.startsWith('~/')) expanded = path.join(userHome, raw.slice(2));
+  if (!path.isAbsolute(expanded)) return null;
+  const resolved = path.resolve(expanded);
+  if (!resolved || resolved === path.sep) return null;
+  return resolved;
+}
+
+export function getGrokbotMissingRootMessage(env = process.env) {
+  const raw = (env[SKILLS_DIR_ENV] || '').trim();
+  if (!raw) {
+    return (
+      `Grok Bot user-scope skill root is not configured. Set ${SKILLS_DIR_ENV} ` +
+      'to the absolute path of the Grok Bot skills/workflows directory before ' +
+      'using --scope user or --global. AIWG does not invent ~/.grokbot.'
+    );
+  }
+  if (raw === '~' || (!raw.startsWith('~/') && !path.isAbsolute(raw))) {
+    return (
+      `${SKILLS_DIR_ENV} must be an absolute path (got '${raw}'). ` +
+      'Relative values and bare ~ are rejected.'
+    );
+  }
+  if (raw.startsWith('~/')) {
+    const expanded = path.join(os.homedir(), raw.slice(2));
+    if (!path.isAbsolute(path.resolve(expanded))) {
+      return `${SKILLS_DIR_ENV} must resolve to an absolute path (got '${raw}').`;
+    }
+  }
+  return (
+    `Grok Bot skill root '${raw}' is not usable. Set ${SKILLS_DIR_ENV} to a ` +
+    'valid absolute directory.'
+  );
+}
+
+// Project-relative paths stay empty: agents/commands/rules are indexed.
+// Skills path is absolute only when the operator configured the env override;
+// otherwise '' so project deploy skips native skill copies.
+function configuredSkillsPath() {
+  return resolveGrokbotSkillsDir() || '';
+}
+
+export const paths = {
+  agents: '',
+  commands: '',
+  get skills() {
+    return configuredSkillsPath();
+  },
+  rules: '',
+};
+
+// Empty when unset — deploySkills resolves AIWG_GROKBOT_SKILLS_DIR dynamically.
+// Never default to ~/.grokbot.
+export const kernelSkillsPath = '';
+
+export const support = {
+  agents: 'indexed',
+  commands: 'indexed',
+  skills: 'native-when-configured',
+  rules: 'indexed',
+};
+
+export const capabilities = {
+  skills: true,
+  rules: false,
+  aggregatedOutput: false,
+  yamlFormat: false,
+  homeDirectoryDeploy: true,
+};
+
+export function mapModel(originalModel) {
+  return originalModel;
+}
+
+export function transformAgent(_srcPath, content) {
+  return content;
+}
+
+export function transformCommand(_srcPath, content) {
+  return content;
+}
+
+export function deployAgents() {
+  return 0;
+}
+
+export function deployCommands() {
+  return 0;
+}
+
+export function deployRules() {
+  return 0;
+}
+
+/**
+ * Deploy skills only when AIWG_GROKBOT_SKILLS_DIR is configured.
+ * Kernel → configured root; standard → index/discovery unless --copy-all
+ * (then `<root>/.aiwg/skills`).
+ */
+export function deploySkills(skillDirs, targetDir, opts = {}) {
+  const root = resolveGrokbotSkillsDir(opts.env || process.env);
+  if (!root) {
+    if (!opts.quiet) {
+      console.log(
+        `\n  Grok Bot: skipping native skill copy (${SKILLS_DIR_ENV} unset). ` +
+          'Skills remain available via aiwg discover / aiwg show.',
+      );
+    }
+    return 0;
+  }
+
+  if (root.includes(`${path.sep}.cursor${path.sep}`) || root.endsWith(`${path.sep}.cursor`) || root.includes('/.cursor/') || root.endsWith('/.cursor')) {
+    throw new Error(
+      `Refusing to deploy Grok Bot skills into a .cursor path (${root}). ` +
+        `Set ${SKILLS_DIR_ENV} to the Grok Bot skills root, not Cursor.`,
+    );
+  }
+
+  const kernelDest = root;
+  const standardDest = path.join(root, '.aiwg', 'skills');
+  if (!opts.quiet) {
+    console.log(
+      `\n  Grok Bot skills root: ${root} (from ${SKILLS_DIR_ENV})` +
+        (opts.dryRun ? ' [dry-run]' : ''),
+    );
+  }
+  return deploySkillsWithKernelRouting(skillDirs, standardDest, kernelDest, {
+    ...opts,
+    copyStandardSkills: opts.copyStandardSkills === true,
+  });
+}
+
+export function createAgentsMd(target, srcRoot, dryRun) {
+  const aiwgRoot = resolveAiwgRoot(srcRoot) || srcRoot;
+  createAgentsMdFromTemplate(target, aiwgRoot, 'grokbot/AGENTS.md.aiwg-template', dryRun);
+}
+
+export async function postDeploy(targetDir, opts = {}) {
+  if (
+    opts.createAgentsMd ||
+    (!opts.commandsOnly && !opts.skillsOnly && !opts.rulesOnly)
+  ) {
+    createAgentsMd(targetDir, opts.srcRoot, opts.dryRun);
+  }
+  if (!opts.quiet) {
+    const root = resolveGrokbotSkillsDir(opts.env || process.env);
+    if (root) {
+      console.log(
+        'Grok Bot: after deploy, start a new agent chat or re-read skills. ' +
+          'Live refresh is not claimed until product behavior is verified.',
+      );
+    } else {
+      console.log(
+        `Grok Bot: project bridge only. Set ${SKILLS_DIR_ENV} for user-scope skill deploy.`,
+      );
+    }
+  }
+}
+
+export function getFileExtension() {
+  return '.md';
+}
+
+/**
+ * Assert user-scope is allowed. Called when the orchestrator is mirroring
+ * to user scope or when opts.scope === 'user'.
+ */
+export function assertUserScopeConfigured(opts = {}) {
+  const root = resolveGrokbotSkillsDir(opts.env || process.env);
+  if (!root) {
+    const err = new Error(getGrokbotMissingRootMessage(opts.env || process.env));
+    err.code = 'GROKBOT_SKILLS_DIR_UNSET';
+    throw err;
+  }
+  return root;
+}
+
+export async function deploy(opts = {}) {
+  const {
+    srcRoot,
+    target,
+    mode,
+    deploySkills: shouldDeploySkills,
+    skillsOnly,
+    commandsOnly,
+    rulesOnly,
+    scope,
+  } = opts;
+
+  if (!opts.quiet) {
+    console.log(`\n=== Grok Bot Provider (experimental) ===`);
+    console.log(`Target: ${target}`);
+    console.log(`Mode: ${mode}`);
+    const root = resolveGrokbotSkillsDir(opts.env || process.env);
+    console.log(
+      `Skills root: ${root || `(unset — set ${SKILLS_DIR_ENV} for user-scope writes)`}`,
+    );
+    if (opts.dryRun) console.log('Dry-run: no filesystem mutations');
+  }
+
+  // Fail closed when caller explicitly requested user scope without a root.
+  if (scope === 'user' || opts.userScope === true) {
+    assertUserScopeConfigured(opts);
+  }
+
+  const skillDirs = [];
+  const normalizedMode = normalizeDeploymentMode(mode);
+
+  if (['general', 'sdlc', 'both', 'all'].includes(normalizedMode)) {
+    if (shouldDeploySkills || skillsOnly) skillDirs.push(...getAddonSkillDirs(srcRoot));
+  }
+
+  const fw = collectFrameworkArtifacts(srcRoot, normalizedMode, {
+    includeAgents: false,
+    includeCommands: false,
+    includeSkills: shouldDeploySkills || skillsOnly,
+    includeRules: false,
+  });
+  skillDirs.push(...fw.skills);
+
+  let count = 0;
+  if ((shouldDeploySkills || skillsOnly) && !commandsOnly && !rulesOnly) {
+    count += deploySkills(skillDirs, target, opts);
+  }
+
+  await postDeploy(target, opts);
+  return count;
+}
+
+export default {
+  name,
+  aliases,
+  paths,
+  kernelSkillsPath,
+  support,
+  capabilities,
+  mapModel,
+  transformAgent,
+  transformCommand,
+  deployAgents,
+  deployCommands,
+  deploySkills,
+  deployRules,
+  createAgentsMd,
+  postDeploy,
+  getFileExtension,
+  deploy,
+  resolveGrokbotSkillsDir,
+  getGrokbotMissingRootMessage,
+  assertUserScopeConfigured,
+};