@moda-ai/cli 1.0.4 → 1.1.0

package/dist/init/index.js

@@ -2,25 +2,25 @@
 import { select } from '@inquirer/prompts';
 import { login, loadToken } from '../auth.js';
 import { selectTenantAndCreateKey } from './tenant.js';
-import { detectProject, installSDK, getInitSnippet } from './detect.js';
-import { detectAgents, configureMCP } from './mcp.js';
+import { detectAgents } from './mcp.js';
 import { installRules } from './rules.js';
 export async function runInit(flags) {
     const yes = flags.yes === true || flags.y === true;
-    const skipSdk = flags.skip_sdk === true;
-    const skipMcp = flags.skip_mcp === true;
     console.log('\n  Moda — LLM Observability for Agents\n');
     // Step 1: Authentication
-    console.log('  Step 1/5: Authentication');
+    console.log('  Step 1/3: Authentication');
     let token = loadToken();
     if (!token) {
-        const action = await select({
-            message: 'Get started',
-            choices: [
-                { name: 'Sign up', value: 'signup' },
-                { name: 'Login', value: 'login' },
-            ],
-        });
+        let action = 'login';
+        if (!yes) {
+            action = await select({
+                message: 'Get started',
+                choices: [
+                    { name: 'Sign up', value: 'signup' },
+                    { name: 'Login', value: 'login' },
+                ],
+            });
+        }
         console.log(`  Opening browser to ${action === 'signup' ? 'sign up' : 'log in'}...`);
         token = await login(action);
         console.log('  Authentication successful');
@@ -29,66 +29,24 @@ export async function runInit(flags) {
         console.log('  Already authenticated (cached token)');
     }
     // Step 2: Tenant + API Key
-    console.log('\n  Step 2/5: Select Organization');
-    const { apiKey, tenantName } = await selectTenantAndCreateKey();
-    // Step 3: SDK
-    if (!skipSdk) {
-        console.log('\n  Step 3/5: Install SDK');
-        const project = await detectProject();
-        if (project.language) {
-            const parts = [project.language];
-            if (project.packageManager)
-                parts.push(project.packageManager);
-            if (project.llmProviders.length > 0) {
-                parts.push(project.llmProviders.join(', '));
-            }
-            console.log(`  Detected: ${parts.join(' / ')}`);
-            await installSDK(project);
-            const snippet = getInitSnippet(project);
-            if (snippet) {
-                console.log('\n  Add this to your entry file:');
-                console.log(snippet);
-            }
-        }
-        else {
-            console.log('  No project detected, skipping SDK installation');
-            console.log('  Install manually: npm install moda-ai (or pip install moda-ai)');
-        }
-    }
-    else {
-        console.log('\n  Step 3/5: Install SDK (skipped)');
-    }
-    // Step 4: MCP
-    if (!skipMcp) {
-        console.log('\n  Step 4/5: Configure MCP Server');
-        const agents = detectAgents();
-        if (agents.length > 0) {
-            console.log(`  Detected: ${agents.map((a) => a.name).join(', ')}`);
-            const configured = await configureMCP(agents, apiKey, yes);
-            if (configured.length > 0) {
-                console.log(`  Configured ${configured.length} agent(s): ${configured.join(', ')}`);
-            }
-        }
-        else {
-            console.log('  No coding agents detected');
-            console.log('  Manual setup: claude mcp add moda -- npx -y @moda-ai/cli');
-        }
-    }
-    else {
-        console.log('\n  Step 4/5: Configure MCP Server (skipped)');
-    }
-    // Step 5: Rules
-    console.log('\n  Step 5/5: Agent Rules (optional)');
-    const agentNames = detectAgents().map((a) => a.name);
-    if (agentNames.length > 0) {
-        await installRules(agentNames, yes);
+    console.log('\n  Step 2/3: Select Organization');
+    const { tenantName } = await selectTenantAndCreateKey();
+    // Step 3: Install SDK integration guide for coding agents
+    console.log('\n  Step 3/3: Install SDK Guide');
+    const agents = detectAgents();
+    if (agents.length > 0) {
+        console.log(`  Detected: ${agents.join(', ')}`);
+        await installRules(agents);
     }
     else {
-        console.log('  Skipped (no agents detected)');
+        console.log('  No coding agents detected, skipping');
     }
     // Done
-    console.log(`\n  Setup complete for ${tenantName}!`);
-    console.log('  Dashboard: https://app.modaflows.com');
+    console.log(`\n  Setup complete for ${tenantName}!\n`);
+    console.log('  Now paste this into your coding agent to integrate Moda:\n');
+    console.log('    Integrate the Moda SDK into this project. Follow the Moda SDK');
+    console.log('    integration guide in the project rules.\n');
+    console.log('  Dashboard: https://moda.dev');
     console.log('');
 }
 //# sourceMappingURL=index.js.map

package/dist/init/mcp.d.ts

@@ -1,8 +1,2 @@
-export interface DetectedAgent {
-    name: string;
-    configPath: string;
-    configKey: string;
-}
-export declare function detectAgents(): DetectedAgent[];
-export declare function configureMCP(agents: DetectedAgent[], apiKey: string, autoYes?: boolean): Promise<string[]>;
+export declare function detectAgents(): string[];
 //# sourceMappingURL=mcp.d.ts.map

package/dist/init/mcp.js

@@ -1,8 +1,7 @@
-// src/init/mcp.ts — MCP server auto-configuration for coding agents
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { join, dirname } from 'node:path';
+// src/init/mcp.ts — Coding agent detection
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
 import { execSync } from 'node:child_process';
-import { checkbox } from '@inquirer/prompts';
 function isOnPath(cmd) {
     try {
         execSync(`which ${cmd}`, { stdio: 'pipe' });
@@ -17,94 +16,12 @@ export function detectAgents() {
     const agents = [];
     // Claude Code
     if (existsSync(join(cwd, '.claude')) || isOnPath('claude')) {
-        agents.push({
-            name: 'Claude Code',
-            configPath: join(cwd, '.claude', 'settings.local.json'),
-            configKey: 'mcpServers',
-        });
+        agents.push('Claude Code');
     }
     // Cursor
     if (existsSync(join(cwd, '.cursor'))) {
-        agents.push({
-            name: 'Cursor',
-            configPath: join(cwd, '.cursor', 'mcp.json'),
-            configKey: 'mcpServers',
-        });
-    }
-    // VS Code
-    if (existsSync(join(cwd, '.vscode'))) {
-        agents.push({
-            name: 'VS Code',
-            configPath: join(cwd, '.vscode', 'mcp.json'),
-            configKey: 'servers',
-        });
+        agents.push('Cursor');
     }
     return agents;
 }
-export async function configureMCP(agents, apiKey, autoYes = false) {
-    if (agents.length === 0)
-        return [];
-    let selected;
-    if (autoYes) {
-        selected = agents;
-    }
-    else {
-        const choices = agents.map((a) => ({
-            name: a.name,
-            value: a,
-            checked: true,
-        }));
-        selected = await checkbox({
-            message: 'Configure MCP server for:',
-            choices,
-        });
-    }
-    const configured = [];
-    for (const agent of selected) {
-        try {
-            writeAgentConfig(agent, apiKey);
-            configured.push(agent.name);
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.error(`  Warning: Failed to configure ${agent.name}: ${message}`);
-        }
-    }
-    // Show manual instructions for skipped agents
-    const skipped = agents.filter((a) => !selected.includes(a));
-    if (skipped.length > 0) {
-        console.log('\n  Manual setup for skipped agents:');
-        for (const agent of skipped) {
-            console.log(`    ${agent.name}: Add moda server to ${agent.configPath}`);
-        }
-    }
-    return configured;
-}
-function writeAgentConfig(agent, apiKey) {
-    // Ensure directory exists
-    const dir = dirname(agent.configPath);
-    mkdirSync(dir, { recursive: true });
-    // Read existing config
-    let config = {};
-    if (existsSync(agent.configPath)) {
-        try {
-            config = JSON.parse(readFileSync(agent.configPath, 'utf8'));
-        }
-        catch {
-            config = {};
-        }
-    }
-    // Merge moda server entry
-    const servers = config[agent.configKey] || {};
-    servers['moda'] = {
-        command: 'npx',
-        args: ['-y', '@moda-ai/cli'],
-        env: {
-            MODA_API_KEY: apiKey,
-        },
-    };
-    config[agent.configKey] = servers;
-    // Write back
-    writeFileSync(agent.configPath, JSON.stringify(config, null, 2) + '\n');
-}
 //# sourceMappingURL=mcp.js.map

package/dist/init/rules.d.ts

@@ -1,2 +1,2 @@
-export declare function installRules(detectedAgents: string[], autoYes?: boolean): Promise<void>;
+export declare function installRules(detectedAgents: string[]): Promise<void>;
 //# sourceMappingURL=rules.d.ts.map

package/dist/init/rules.js

@@ -1,72 +1,165 @@
-// src/init/rules.ts — Agent rules file installation
-import { existsSync, readFileSync, writeFileSync, appendFileSync, mkdirSync } from 'node:fs';
-import { join, dirname } from 'node:path';
+// src/init/rules.ts — Install Moda agent skills into the user's project.
+//
+// Each entry in SKILLS is a directory under <package>/skills/ that contains a
+// SKILL.md (Claude Code format). At install time we copy each skill into every
+// detected coding agent, translating frontmatter where the agent expects a
+// different shape (e.g. Cursor's .mdc rules).
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { confirm } from '@inquirer/prompts';
-const MODA_RULES_CONTENT = `
-
-## Moda SDK
-
-Moda is integrated in this project for LLM observability. The \`moda-ai\` SDK
-auto-instruments OpenAI and Anthropic calls via OpenTelemetry.
-
-### Initialization
-
-- TypeScript: \`import { Moda } from 'moda-ai'; await Moda.init(process.env.MODA_API_KEY!);\`
-- Python: \`import moda; moda.init()\` (reads MODA_API_KEY from env)
-
-### Conversation Tracking
-
-Set conversation ID before LLM calls to group multi-turn conversations:
-- TypeScript: \`Moda.conversationId = 'session-id';\`
-- Python: \`moda.conversation_id = 'session-id'\`
-
-### Before Exit
-
-Flush pending traces before the process exits:
-- TypeScript: \`await Moda.flush();\`
-- Python: \`moda.flush()\`
-`;
-const AGENT_RULES_FILES = {
-    'Claude Code': 'CLAUDE.md',
-    'Cursor': '.cursor/rules/moda.mdc',
+// --- Package path resolution ---
+//
+// Resolved relative to this module's URL so it works whether we're running
+// from src/ in dev or from the published dist/ inside node_modules.
+const PACKAGE_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+const SKILLS_SOURCE_DIR = join(PACKAGE_ROOT, 'skills');
+const SKILLS = [
+    {
+        id: 'integrate-moda',
+        label: 'integrate-moda — instrument this project with the Moda SDK',
+    },
+    {
+        id: 'moda-cli',
+        label: 'moda-cli — let coding agents query Moda analytics via the CLI',
+    },
+];
+const ADAPTERS = {
+    'Claude Code': {
+        name: 'Claude Code',
+        targetFor: (skillId) => ({
+            dir: join('.claude', 'skills', skillId),
+            filename: 'SKILL.md',
+        }),
+        transform: (content) => content,
+    },
+    'Cursor': {
+        name: 'Cursor',
+        targetFor: (skillId) => ({
+            dir: join('.cursor', 'rules'),
+            filename: `${skillId}.mdc`,
+        }),
+        transform: claudeSkillToCursorRule,
+    },
 };
-export async function installRules(detectedAgents, autoYes = false) {
-    const applicable = detectedAgents.filter((a) => a in AGENT_RULES_FILES);
-    if (applicable.length === 0) {
-        console.log('  No supported agents detected for rules files');
+// --- Frontmatter translation ---
+//
+// Cursor's .mdc rules use a different frontmatter shape:
+//   ---
+//   description: "..."
+//   alwaysApply: false
+//   ---
+// The body markdown is identical, so we strip the Claude frontmatter, lift
+// the description out of it, and emit Cursor's variant.
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/;
+const DESCRIPTION_RE = /^description:\s*(.+?)\s*$/m;
+function claudeSkillToCursorRule(skillContent) {
+    const match = FRONTMATTER_RE.exec(skillContent);
+    if (!match) {
+        // Body without frontmatter — pass through untouched rather than guess.
+        return skillContent;
+    }
+    const [, frontmatter, body] = match;
+    const descMatch = DESCRIPTION_RE.exec(frontmatter);
+    const description = descMatch?.[1].trim() ?? '';
+    // JSON.stringify gives us a YAML-safe double-quoted string with proper
+    // escaping for any quotes or backslashes inside the description.
+    const cursorFrontmatter = `---\n` +
+        `description: ${JSON.stringify(description)}\n` +
+        `alwaysApply: false\n` +
+        `---\n`;
+    return `${cursorFrontmatter}\n${body.replace(/^\s+/, '')}`;
+}
+// --- I/O helpers ---
+function loadSkillSource(skillId) {
+    const path = join(SKILLS_SOURCE_DIR, skillId, 'SKILL.md');
+    if (!existsSync(path)) {
+        throw new Error(`Skill source missing: ${path}`);
+    }
+    return readFileSync(path, 'utf8');
+}
+function installSkillForAgent(skill, adapter, content) {
+    const { dir, filename } = adapter.targetFor(skill.id);
+    const dirPath = join(process.cwd(), dir);
+    const filePath = join(dirPath, filename);
+    const relativePath = join(dir, filename);
+    try {
+        mkdirSync(dirPath, { recursive: true });
+        if (existsSync(filePath)) {
+            return { agent: adapter.name, relativePath, status: 'exists' };
+        }
+        writeFileSync(filePath, adapter.transform(content));
+        return { agent: adapter.name, relativePath, status: 'wrote' };
+    }
+    catch (err) {
+        return {
+            agent: adapter.name,
+            relativePath,
+            status: 'failed',
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+// --- Public entry point ---
+export async function installRules(detectedAgents) {
+    const adapters = detectedAgents
+        .map((a) => ADAPTERS[a])
+        .filter((a) => a !== undefined);
+    if (adapters.length === 0) {
+        console.log('  No supported coding agents detected');
         return;
     }
-    let shouldInstall = autoYes;
+    const agentList = adapters.map((a) => a.name).join(', ');
+    const skillList = SKILLS.map((s) => `\n    • ${s.label}`).join('');
+    const shouldInstall = await confirm({
+        message: `Install Moda skills for ${agentList}?${skillList}\n  Continue?`,
+        default: true,
+    });
     if (!shouldInstall) {
-        shouldInstall = await confirm({
-            message: 'Install agent rules for coding assistants?',
-            default: true,
-        });
-    }
-    if (!shouldInstall)
+        console.log('  Skipped');
         return;
-    for (const agent of applicable) {
-        const filePath = join(process.cwd(), AGENT_RULES_FILES[agent]);
+    }
+    let wrote = 0;
+    let skipped = 0;
+    let failed = 0;
+    for (const skill of SKILLS) {
+        let content;
         try {
-            const dir = dirname(filePath);
-            mkdirSync(dir, { recursive: true });
-            if (existsSync(filePath)) {
-                const content = readFileSync(filePath, 'utf8');
-                if (content.includes('## Moda SDK')) {
-                    console.log(`  ${agent}: Moda SDK section already exists in ${AGENT_RULES_FILES[agent]}`);
-                    continue;
-                }
-                appendFileSync(filePath, MODA_RULES_CONTENT);
-            }
-            else {
-                writeFileSync(filePath, MODA_RULES_CONTENT.trimStart());
-            }
-            console.log(`  Added Moda SDK reference to ${AGENT_RULES_FILES[agent]}`);
+            content = loadSkillSource(skill.id);
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            console.error(`  Warning: Failed to write ${AGENT_RULES_FILES[agent]}: ${message}`);
+            console.error(`  Warning: ${message}`);
+            failed += adapters.length;
+            continue;
         }
+        for (const adapter of adapters) {
+            const outcome = installSkillForAgent(skill, adapter, content);
+            switch (outcome.status) {
+                case 'wrote':
+                    console.log(`  ${outcome.agent}: wrote ${outcome.relativePath}`);
+                    wrote++;
+                    break;
+                case 'exists':
+                    console.log(`  ${outcome.agent}: ${outcome.relativePath} already exists — skipping`);
+                    skipped++;
+                    break;
+                case 'failed':
+                    console.error(`  ${outcome.agent}: failed to write ${outcome.relativePath} — ${outcome.error}`);
+                    failed++;
+                    break;
+            }
+        }
+    }
+    const summary = [
+        wrote && `${wrote} written`,
+        skipped && `${skipped} already present`,
+        failed && `${failed} failed`,
+    ]
+        .filter(Boolean)
+        .join(', ');
+    if (summary) {
+        console.log(`  Done — ${summary}`);
     }
 }
 //# sourceMappingURL=rules.js.map

package/dist/init/tenant.js

@@ -1,7 +1,5 @@
 // src/init/tenant.ts — Tenant selection and API key provisioning
 import { select } from '@inquirer/prompts';
-import { readFileSync, writeFileSync, existsSync, appendFileSync } from 'node:fs';
-import { join } from 'node:path';
 import { authFetch } from '../auth.js';
 export async function selectTenantAndCreateKey() {
     // 1. Fetch CLI context
@@ -14,7 +12,7 @@ export async function selectTenantAndCreateKey() {
     console.log(`  Authenticated as ${ctx.user.email}`);
     // 2. Select tenant
     if (ctx.tenants.length === 0) {
-        console.error('  No organizations found. Create one at https://app.modaflows.com');
+        console.error('  No organizations found. Create one at https://moda.dev');
         process.exit(1);
     }
     let tenantId;
@@ -47,45 +45,9 @@ export async function selectTenantAndCreateKey() {
         throw new Error(`Failed to create API key (${bootstrapRes.status}): ${body}`);
     }
     const result = (await bootstrapRes.json());
-    // 4. Write .env
-    writeEnvFile(result.apiKey);
-    // 5. Update .gitignore
-    ensureGitignore();
-    console.log('  API key created and saved to .env');
+    console.log('  API key created.\n');
+    console.log(`  Add this to your environment variables:\n`);
+    console.log(`    MODA_API_KEY=${result.apiKey}\n`);
     return result;
 }
-function writeEnvFile(apiKey) {
-    const envPath = join(process.cwd(), '.env');
-    const line = `MODA_API_KEY=${apiKey}`;
-    if (existsSync(envPath)) {
-        const content = readFileSync(envPath, 'utf8');
-        if (content.includes('MODA_API_KEY=')) {
-            // Replace existing line
-            const updated = content.replace(/^MODA_API_KEY=.*$/m, line);
-            writeFileSync(envPath, updated);
-        }
-        else {
-            // Append
-            const separator = content.endsWith('\n') ? '' : '\n';
-            appendFileSync(envPath, `${separator}${line}\n`);
-        }
-    }
-    else {
-        writeFileSync(envPath, `${line}\n`);
-    }
-}
-function ensureGitignore() {
-    const gitignorePath = join(process.cwd(), '.gitignore');
-    if (existsSync(gitignorePath)) {
-        const content = readFileSync(gitignorePath, 'utf8');
-        const lines = content.split('\n').map((l) => l.trim());
-        if (!lines.includes('.env')) {
-            const separator = content.endsWith('\n') ? '' : '\n';
-            appendFileSync(gitignorePath, `${separator}.env\n`);
-        }
-    }
-    else {
-        writeFileSync(gitignorePath, '.env\n');
-    }
-}
 //# sourceMappingURL=tenant.js.map

package/dist/schemas.d.ts

@@ -71,14 +71,20 @@ export declare const FrustrationsSchema: z.ZodObject<{
     days_back: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
     limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
     offset: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    include_window: z.ZodOptional<z.ZodEffects<z.ZodBoolean, boolean, unknown>>;
+    window: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
     days_back?: number | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
+    window?: number | undefined;
+    include_window?: boolean | undefined;
 }, {
     days_back?: number | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
+    window?: number | undefined;
+    include_window?: unknown;
 }>;
 export declare const ToolFailuresSchema: z.ZodObject<{
     days_back: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
@@ -93,17 +99,82 @@ export declare const ToolFailureDetailSchema: z.ZodObject<{
     days_back: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
     limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
     offset: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    include_window: z.ZodOptional<z.ZodEffects<z.ZodBoolean, boolean, unknown>>;
+    window: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
     tool_name: string;
     days_back?: number | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
+    window?: number | undefined;
+    include_window?: boolean | undefined;
     subtype?: string | undefined;
 }, {
     tool_name: string;
     days_back?: number | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
+    window?: number | undefined;
+    include_window?: unknown;
     subtype?: string | undefined;
 }>;
+/** moda workflows — recurring workflow catalog (read from agent_job_classes). */
+export declare const WorkflowsSchema: z.ZodObject<{
+    time_range: z.ZodOptional<z.ZodDefault<z.ZodEnum<["all", "1h", "3d", "7d", "24h", "30d", "90d"]>>>;
+    user_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    time_range?: "all" | "1h" | "3d" | "7d" | "24h" | "30d" | "90d" | undefined;
+    user_id?: string | undefined;
+}, {
+    time_range?: "all" | "1h" | "3d" | "7d" | "24h" | "30d" | "90d" | undefined;
+    user_id?: string | undefined;
+}>;
+/** moda runs — list workflow executions with classified outcomes. */
+export declare const RunsSchema: z.ZodObject<{
+    time_range: z.ZodOptional<z.ZodDefault<z.ZodEnum<["all", "1h", "3d", "7d", "24h", "30d", "90d"]>>>;
+    outcome: z.ZodOptional<z.ZodEnum<["running", "succeeded", "partial", "failed", "loop", "abandoned", "unknown"]>>;
+    /** Filter to one workflow class id (e.g. cron:helpscout-triage-hourly). */
+    class_id: z.ZodOptional<z.ZodString>;
+    user_id: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    offset: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    time_range?: "all" | "1h" | "3d" | "7d" | "24h" | "30d" | "90d" | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    user_id?: string | undefined;
+    outcome?: "running" | "succeeded" | "partial" | "failed" | "loop" | "abandoned" | "unknown" | undefined;
+    class_id?: string | undefined;
+}, {
+    time_range?: "all" | "1h" | "3d" | "7d" | "24h" | "30d" | "90d" | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    user_id?: string | undefined;
+    outcome?: "running" | "succeeded" | "partial" | "failed" | "loop" | "abandoned" | "unknown" | undefined;
+    class_id?: string | undefined;
+}>;
+/** moda run <runId> — single execution detail with side-effect receipts. */
+export declare const RunDetailSchema: z.ZodObject<{
+    run_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    run_id: string;
+}, {
+    run_id: string;
+}>;
+/** moda loops — currently active loop detections. */
+export declare const LoopsSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    limit?: number | undefined;
+}, {
+    limit?: number | undefined;
+}>;
+/** moda loop <detectionId> — single loop detection detail. */
+export declare const LoopDetailSchema: z.ZodObject<{
+    detection_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    detection_id: string;
+}, {
+    detection_id: string;
+}>;
 //# sourceMappingURL=schemas.d.ts.map