gsd-antigravity-kit 1.32.0 → 2.0.0

package/.agent/skills/selectpaste-update/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: selectpaste-update
+description: "Specialized maintenance skill to synchronize GSD command registries with remote documentation and local backups. Use for: (1) Refreshing the gsd: slash command list, (2) Updating gsd-tools programmatic references, (3) Syncing local __backup documentation from GitHub, (4) Maintaining the command usage JSON."
+---
+
+# selectpaste-update
+
+## Purpose
+
+The **selectpaste-update** skill automates the synchronization between the GSD documentation and the programmatic command registry used by GSD tools and UI components. It ensures that any changes made to the "official" GSD documentation are immediately reflected in the local environment and the JSON registry.
+
+## Triggers
+
+This skill triggers on maintenance and synchronization requests such as:
+- "sync gsd commands"
+- "refresh command registry"
+- "update gsd-tools reference"
+- "sync gsd docs from github"
+- "maintenance: registry refresh"
+
+## Core Workflow
+
+### 1. Synchronize Command Registry
+
+The primary action of this skill is to run the registry synchronization script. This process performs the following steps:
+1.  **Fetch**: Downloads the latest `COMMANDS.md` and `CLI-TOOLS.md` from the `gsd-build/get-shit-done` repository.
+2.  **Local Sync**: Updates `__backup/COMMANDS.md` and `__backup/CLI-TOOLS.md` with the fetched content.
+3.  **Backup**: Creates a `.bak` timestamped copy of the existing `__backup/commands.json`.
+4.  **Merge**: Parses the Markdown files and merges new data into `commands.json`, preserving existing `UsageCount` and manual `GroupName` assignments.
+
+**Command:**
+```powershell
+py .agent/skills/selectpaste-update/scripts/sync-commands.py
+```
+
+## Best Practices
+
+- **Verify Before Sync**: If you have local modifications in `__backup/` that are not yet on GitHub, run with the `--local` flag to prevent overwriting them.
+- **Review Diffs**: Always review the git diff for `__backup/commands.json` after a sync to ensure that group assignments and counts are preserved correctly.
+- **Reporting**: After a successful sync, the script provides a summary of added, updated, and deprecated commands.
+
+## Reference Material
+
+- [COMMANDS.md](file:///c:/projects/GSD-Antigravity/__backup/COMMANDS.md) - Slash command reference
+- [CLI-TOOLS.md](file:///c:/projects/GSD-Antigravity/__backup/CLI-TOOLS.md) - Programmatic tools reference
+- [commands.json](file:///c:/projects/GSD-Antigravity/__backup/commands.json) - The generated registry

package/.agent/skills/selectpaste-update/scripts/sync-commands.py

@@ -0,0 +1,317 @@
+import json
+import os
+import re
+import urllib.request
+from datetime import datetime
+import shutil
+import sys
+
+# Configuration
+CONFIG = {
+    "backup_dir": "__backup",
+    "json_file": "commands.json",
+    "md_commands": "COMMANDS.md",
+    "md_cli": "CLI-TOOLS.md",
+    "remote_commands": "https://raw.githubusercontent.com/gsd-build/get-shit-done/main/docs/COMMANDS.md",
+    "remote_cli": "https://raw.githubusercontent.com/gsd-build/get-shit-done/main/docs/CLI-TOOLS.md"
+}
+
+def fetch_url(url):
+    try:
+        with urllib.request.urlopen(url) as response:
+            return response.read().decode('utf-8')
+    except Exception as e:
+        print(f"⚠️ Failed to fetch {url}: {e}")
+        return None
+
+def save_local(filename, content):
+    path = os.path.join(CONFIG["backup_dir"], filename)
+    with open(path, 'w', encoding='utf-8') as f:
+        f.write(content)
+    print(f"✅ Updated local cache: {path}")
+
+def backup_json(path):
+    if os.path.exists(path):
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        backup_path = f"{path}.{timestamp}.bak"
+        shutil.copy2(path, backup_path)
+        print(f"📦 Created backup: {backup_path}")
+
+def parse_commands_md(content):
+    commands = []
+    # Match headers like ### `/gsd-something` or ### `/gsd-something [args]`
+    pattern = r'### `/(gsd-[a-z0-9-]+)(.*?)`'
+    sections = re.split(pattern, content)
+    
+    # sections[0] is preamble
+    # Then it comes in triplets: name, args, body
+    for i in range(1, len(sections), 3):
+        cmd_slug = sections[i]
+        cmd_args = sections[i+1].strip()
+        body = sections[i+2].strip()
+        
+        # Normalize to colon format for value
+        # Mapping /gsd-new-project to gsd:new-project
+        clean_name = cmd_slug.replace('gsd-', '')
+        value = f"gsd:{clean_name}"
+        if cmd_args:
+            value += f" {cmd_args}"
+            
+        # Extract first paragraph as base description
+        desc_lines = []
+        for line in body.split('\n'):
+            if line.strip() and not line.startswith('|') and not line.startswith('**'):
+                desc_lines.append(line.strip())
+            if len(desc_lines) > 2: # Keep it concise
+                break
+        
+        description = " ".join(desc_lines)
+        
+        # Extract example if exists
+        examples = re.findall(r'```bash\n(.*?)\n```', body, re.DOTALL)
+        if examples:
+            description += f"\n\nExample:\n{examples[0].strip()}"
+
+        commands.append({
+            "label": clean_name,
+            "value": value,
+            "description": description,
+            "type": "gsd"
+        })
+    return commands
+
+def parse_cli_md(content):
+    commands = []
+    # Match code blocks starting with node gsd-tools.cjs
+    pattern = r'node gsd-tools\.cjs (.*?)(?=\n|#|$)'
+    matches = re.findall(pattern, content)
+    
+    # We also want to find descriptions before these blocks
+    # This is harder with regex, let's just find the commands first
+    for match in matches:
+        clean_cmd = match.strip()
+        # Mapping to gsd-tools command
+        value = f"gsd:gsd-tools {clean_cmd}"
+        
+        # For CLI tools, label is the command itself
+        label = clean_cmd
+        
+        # Logic to find description based on preceding lines
+        # In CLI-TOOLS.md, descriptions are often in comments like # Load full project config
+        # Let's search for the line before the match
+        lines = content.split('\n')
+        desc = ""
+        for i, line in enumerate(lines):
+            if f"node gsd-tools.cjs {clean_cmd}" in line:
+                # Look up to 2 lines back for a comment
+                for j in range(i-1, max(-1, i-3), -1):
+                    if lines[j].strip().startswith('#'):
+                        desc = lines[j].strip().lstrip('#').strip()
+                        break
+                break
+
+        commands.append({
+            "label": label,
+            "value": value,
+            "description": desc or "CLI utility command.",
+            "type": "tool"
+        })
+    return commands
+
+def get_base_name(full_val):
+    # Normalize: strip common prefixes
+    val = full_val.strip()
+    
+    # 1. Handle gsd-tools specifically
+    if "gsd-tools" in val:
+        # Strip everything before gsd-tools or node gsd-tools.cjs
+        clean = re.sub(r'.*?gsd-tools(\.cjs)?\s+', '', val)
+        # Take words that are not flags or placeholders or complex args
+        parts = clean.split(' ')
+        res = []
+        for p in parts:
+            if not p or p.startswith('-') or '<' in p or '[' in p or '@' in p or '|' in p or '(' in p:
+                break
+            res.append(p)
+        return "gsd-tools " + " ".join(res).strip()
+    
+    # 2. Handle slash commands
+    if val.startswith('/') or val.startswith('gsd:'):
+        clean = re.sub(r'^(gsd:|/)', '', val)
+        # Take the first word only (the command name)
+        return clean.split(' ')[0].strip()
+        
+    # 3. Fallback
+    return val.split(' ')[0].strip()
+
+def sync():
+    is_local = "--local" in sys.argv
+    print(f"🔄 Starting GSD Registry Sync{' (LOCAL MODE)' if is_local else ''}...")
+    
+    # 1. & 2. Fetch / Load
+    cmd_content = None
+    cli_content = None
+
+    if not is_local:
+        cmd_content = fetch_url(CONFIG["remote_commands"])
+        cli_content = fetch_url(CONFIG["remote_cli"])
+        
+        # Update local cache if fetch succeeded
+        if cmd_content: 
+            save_local(CONFIG["md_commands"], cmd_content)
+        if cli_content: 
+            save_local(CONFIG["md_cli"], cli_content)
+
+    # Load from local if fetch failed or local mode enabled
+    if not cmd_content:
+        local_cmd_path = os.path.join(CONFIG["backup_dir"], CONFIG["md_commands"])
+        if os.path.exists(local_cmd_path):
+            print(f"ℹ️ Loading local {CONFIG['md_commands']}.")
+            with open(local_cmd_path, 'r', encoding='utf-8') as f:
+                cmd_content = f.read()
+            
+    if not cli_content:
+        local_cli_path = os.path.join(CONFIG["backup_dir"], CONFIG["md_cli"])
+        if os.path.exists(local_cli_path):
+            print(f"ℹ️ Loading local {CONFIG['md_cli']}.")
+            with open(local_cli_path, 'r', encoding='utf-8') as f:
+                cli_content = f.read()
+    
+    if not cmd_content or not cli_content:
+        print("❌ Error: Could not find command or CLI markdown files.")
+        return
+
+    # 3. Backup JSON
+    json_path = os.path.join(CONFIG["backup_dir"], CONFIG["json_file"])
+    backup_json(json_path)
+    
+    # 4. Parse Latest
+    new_gsd_cmds = parse_commands_md(cmd_content)
+    new_tool_cmds = parse_cli_md(cli_content)
+    
+    # 5. Load Existing to Merge
+    try:
+        with open(json_path, 'r', encoding='utf-8') as f:
+            existing_data = json.load(f)
+    except Exception as e:
+        print(f"⚠️ Failed to load existing JSON: {e}")
+        existing_data = []
+
+
+    # Flatten existing for easier lookup by base command
+    # We prioritize non-"NEW" groups if duplicates exist
+    existing_map = {}
+    for group in existing_data:
+        gname = group["name"]
+        is_new_group = gname.startswith("[NEW]")
+        
+        for cmd in group.get("commands", []):
+            base_name = get_base_name(cmd.get("value", ""))
+            
+            # If we haven't seen this base yet, or if previous was from a [NEW] group
+            # but current isn't, overwrite to prioritize the permanent group
+            if base_name not in existing_map or (existing_map[base_name]["IsNewGroup"] and not is_new_group):
+                existing_map[base_name] = {
+                    "Metadata": cmd,
+                    "Group": gname,
+                    "IsNewGroup": is_new_group
+                }
+
+    # 6. Merge & Classify
+    groups = {g["name"]: g for g in existing_data}
+    
+    # Global Deduplication:
+    # Ensure each command only exists in its most specialized group (favor non-"NEW" groups)
+    for base_name, match_info in existing_map.items():
+        primary_group = match_info["Group"]
+        for gname in groups:
+            if gname != primary_group:
+                groups[gname]["commands"] = [
+                    d for d in groups[gname]["commands"]
+                    if get_base_name(d["value"]) != base_name
+                ]
+
+    # Ensure staging groups exist
+    if "[NEW] GSD COMMANDS" not in groups:
+        groups["[NEW] GSD COMMANDS"] = {"name": "[NEW] GSD COMMANDS", "description": "Newly discovered slash commands.", "commands": []}
+    if "[NEW] GSD-TOOLS" not in groups:
+        groups["[NEW] GSD-TOOLS"] = {"name": "[NEW] GSD-TOOLS", "description": "Newly discovered gsd-tools commands.", "commands": []}
+
+    processed_names = set()
+
+    def merge_cmd(new_cmd, default_group):
+        full_val = new_cmd["value"]
+        base_name = get_base_name(full_val)
+        processed_names.add(base_name)
+        
+        if base_name in existing_map:
+            # Update existing
+            old_cmd = existing_map[base_name]["Metadata"]
+            group_name = existing_map[base_name]["Group"]
+            
+            # Preserve numeric prefix if label has one
+            label = new_cmd["label"]
+            match = re.match(r'^(\d+\.)\s*(.*)', old_cmd.get("label", ""))
+            if match:
+                label = f"{match.group(1)} {label}"
+            
+            updated_cmd = {
+                "label": label,
+                "value": full_val, # Use new value (with potentially updated args)
+                "description": new_cmd["description"],
+                "GroupName": group_name,
+                "UsageCount": old_cmd.get("UsageCount", 0),
+                "FullDisplay": f"[{group_name.upper()}] {label} -> {full_val}",
+                "TabDisplay": f"{label} -> {full_val}"
+            }
+            # Put back in the right group
+            # Clear ANY other old versions just in case
+            groups[group_name]["commands"] = [
+                d for d in groups[group_name]["commands"] 
+                if get_base_name(d["value"]) != base_name
+            ]
+            groups[group_name]["commands"].append(updated_cmd)
+        else:
+            # Add to staged
+            new_entry = {
+                "label": new_cmd["label"],
+                "value": full_val,
+                "description": new_cmd["description"],
+                "GroupName": default_group,
+                "UsageCount": 0,
+                "FullDisplay": f"[{default_group.upper()}] {new_cmd['label']} -> {full_val}",
+                "TabDisplay": f"{new_cmd['label']} -> {full_val}"
+            }
+            groups[default_group]["commands"].append(new_entry)
+
+    for cmd in new_gsd_cmds:
+        merge_cmd(cmd, "[NEW] GSD COMMANDS")
+    
+    for cmd in new_tool_cmds:
+        merge_cmd(cmd, "[NEW] GSD-TOOLS")
+
+    # Re-order commands in each group (numeric sort)
+    for gname in groups:
+        group = groups[gname]
+        group["commands"].sort(key=lambda x: x.get("label", ""))
+
+    # Convert groups back to list
+    # Preserve original group ordering
+    ordered_group_names = [g["name"] for g in existing_data]
+    for gname in groups:
+        if gname not in ordered_group_names:
+            ordered_group_names.append(gname)
+    
+    final_output = [groups[name] for name in ordered_group_names if groups[name]["commands"]]
+
+    # 7. Write Result
+    with open(json_path, 'w', encoding='utf-8') as f:
+        json.dump(final_output, f, indent=2, ensure_ascii=False)
+    
+    print(f"✨ Successfully synchronized {len(processed_names)} commands to {json_path}")
+
+if __name__ == "__main__":
+    # Ensure backup dir exists
+    if not os.path.exists(CONFIG["backup_dir"]):
+        os.makedirs(CONFIG["backup_dir"])
+    sync()

package/README.md

@@ -3,8 +3,8 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Antigravity Compatible](https://img.shields.io/badge/Antigravity-Compatible-purple.svg?logo=google&logoColor=white)](https://github.com/google-deepmind/antigravity)
 [![NPM Version](https://img.shields.io/npm/v/gsd-antigravity-kit.svg?logo=npm)](https://www.npmjs.com/package/gsd-antigravity-kit)
-[![Release Version](https://img.shields.io/badge/Release-v1.32.0-blue?style=flat-square)](https://github.com/dturkuler/GSD-Antigravity/releases/latest)
-[![GSD Version](https://img.shields.io/badge/gsd-v1.32.0-orange?style=flat-square)](https://github.com/glittercowboy/get-shit-done)
+[![Release Version](https://img.shields.io/badge/Release-v2.0.0-blue?style=flat-square)](https://github.com/dturkuler/GSD-Antigravity/releases/latest)
+[![GSD Version](https://img.shields.io/badge/gsd-v1.34.2-orange?style=flat-square)](https://github.com/glittercowboy/get-shit-done)
 
 **GSD-Antigravity Kit** is the official bootstrapping and management utility for the [Get Shit Done (GSD)](https://github.com/glittercowboy/get-shit-done) protocol within the Antigravity AI framework. It serves as a high-performance **Installer** and **Skill Manager** that provision, optimizes, and maintains GSD skills in your AG environment.
 
@@ -103,3 +103,5 @@ The core logic, philosophy, and original script engine were created by **[glitte
 
 
 
+
+

package/bin/install.js

@@ -1,116 +1,116 @@
-#!/usr/bin/env node
-
-const fs = require('fs');
-const path = require('path');
-const readline = require('readline');
-const { execSync } = require('child_process');
-
-const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-});
-
-const ask = (query) => new Promise((resolve) => rl.question(query, (ans) => resolve(ans.toLowerCase().trim())));
-
-async function install() {
-    const targetDir = process.cwd();
-    const sourceAgentDir = path.join(__dirname, '..', '.agent');
-    const skillsSourceDir = path.join(sourceAgentDir, 'skills');
-    
-    // Skills to check/install
-    const skillNames = ['gsd', 'gsd-converter'];
-    const targetSkillsDir = path.join(targetDir, '.agent', 'skills');
-
-    console.log('\n🌌 GSD-Antigravity Skill System Installer\n');
-
-    try {
-        // 1. Check for existing skills
-        const existing = [];
-        for (const name of skillNames) {
-            if (fs.existsSync(path.join(targetSkillsDir, name))) {
-                existing.push(name);
-            }
-        }
-
-        if (existing.length > 0) {
-            console.log(`⚠️  Detected existing skills in .agent/skills/: ${existing.join(', ')}`);
-            const confirmRemove = await ask(`Do you want to REMOVE existing skills and perform a fresh install? (y/n): `);
-            if (confirmRemove === 'y') {
-                for (const name of existing) {
-                    const p = path.join(targetSkillsDir, name);
-                    console.log(`  🗑️  Removing ${name}...`);
-                    fs.rmSync(p, { recursive: true, force: true });
-                }
-            } else {
-                console.log('  ⏩ Skipping removal. New files will be merged/overwritten.');
-            }
-        }
-
-        // 2. Interactive Installation Selection
-        const installGsd = await ask(`Install GSD skill? (y/n) [default: y]: `);
-        const installConverter = await ask(`Install GSD-Converter skill? (y/n) [default: y]: `);
-
-        const selection = {
-            'gsd': installGsd !== 'n',
-            'gsd-converter': installConverter !== 'n'
-        };
-
-        // 3. Perform Installation
-        if (!fs.existsSync(targetSkillsDir)) {
-            fs.mkdirSync(targetSkillsDir, { recursive: true });
-        }
-
-        // Also copy rules if they exist
-        const sourceRulesDir = path.join(sourceAgentDir, 'rules');
-        const targetRulesDir = path.join(targetDir, '.agent', 'rules');
-        if (fs.existsSync(sourceRulesDir)) {
-            copyFolderSync(sourceRulesDir, targetRulesDir);
-        }
-
-        let installedCount = 0;
-        for (const [name, shouldInstall] of Object.entries(selection)) {
-            if (shouldInstall) {
-                const src = path.join(skillsSourceDir, name);
-                const tgt = path.join(targetSkillsDir, name);
-                if (fs.existsSync(src)) {
-                    console.log(`📦 Installing ${name}...`);
-                    copyFolderSync(src, tgt);
-                    installedCount++;
-                }
-            }
-        }
-
-        if (installedCount > 0) {
-            console.log('\n✅ Installation completed successfully.');
-            if (selection['gsd-converter']) {
-                console.log('\n✨ To initialize the GSD engine, run:');
-                console.log('  py .agent/skills/gsd-converter/scripts/convert.py gsd\n');
-            }
-        } else {
-            console.log('\nℹ️  No skills were selected for installation.');
-        }
-
-    } catch (err) {
-        console.error('\n❌ Installation failed:', err.message);
-    } finally {
-        rl.close();
-    }
-}
-
-function copyFolderSync(from, to) {
-    if (!fs.existsSync(to)) {
-        fs.mkdirSync(to, { recursive: true });
-    }
-    fs.readdirSync(from).forEach(element => {
-        const srcPath = path.join(from, element);
-        const tgtPath = path.join(to, element);
-        const stat = fs.lstatSync(srcPath);
-        if (stat.isFile()) {
-            fs.copyFileSync(srcPath, tgtPath);
-        } else if (stat.isDirectory()) {
-            copyFolderSync(srcPath, tgtPath);
-        }
-    });
-}
-
-install();
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { execSync } = require('child_process');
+
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+
+const ask = (query) => new Promise((resolve) => rl.question(query, (ans) => resolve(ans.toLowerCase().trim())));
+
+async function install() {
+    const targetDir = process.cwd();
+    const sourceAgentDir = path.join(__dirname, '..', '.agent');
+    const skillsSourceDir = path.join(sourceAgentDir, 'skills');
+    
+    // Skills to check/install
+    const skillNames = ['gsd', 'gsd-converter'];
+    const targetSkillsDir = path.join(targetDir, '.agent', 'skills');
+
+    console.log('\n🌌 GSD-Antigravity Skill System Installer\n');
+
+    try {
+        // 1. Check for existing skills
+        const existing = [];
+        for (const name of skillNames) {
+            if (fs.existsSync(path.join(targetSkillsDir, name))) {
+                existing.push(name);
+            }
+        }
+
+        if (existing.length > 0) {
+            console.log(`⚠️  Detected existing skills in .agent/skills/: ${existing.join(', ')}`);
+            const confirmRemove = await ask(`Do you want to REMOVE existing skills and perform a fresh install? (y/n): `);
+            if (confirmRemove === 'y') {
+                for (const name of existing) {
+                    const p = path.join(targetSkillsDir, name);
+                    console.log(`  🗑️  Removing ${name}...`);
+                    fs.rmSync(p, { recursive: true, force: true });
+                }
+            } else {
+                console.log('  ⏩ Skipping removal. New files will be merged/overwritten.');
+            }
+        }
+
+        // 2. Interactive Installation Selection
+        const installGsd = await ask(`Install GSD skill? (y/n) [default: y]: `);
+        const installConverter = await ask(`Install GSD-Converter skill? (y/n) [default: y]: `);
+
+        const selection = {
+            'gsd': installGsd !== 'n',
+            'gsd-converter': installConverter !== 'n'
+        };
+
+        // 3. Perform Installation
+        if (!fs.existsSync(targetSkillsDir)) {
+            fs.mkdirSync(targetSkillsDir, { recursive: true });
+        }
+
+        // Also copy rules if they exist
+        const sourceRulesDir = path.join(sourceAgentDir, 'rules');
+        const targetRulesDir = path.join(targetDir, '.agent', 'rules');
+        if (fs.existsSync(sourceRulesDir)) {
+            copyFolderSync(sourceRulesDir, targetRulesDir);
+        }
+
+        let installedCount = 0;
+        for (const [name, shouldInstall] of Object.entries(selection)) {
+            if (shouldInstall) {
+                const src = path.join(skillsSourceDir, name);
+                const tgt = path.join(targetSkillsDir, name);
+                if (fs.existsSync(src)) {
+                    console.log(`📦 Installing ${name}...`);
+                    copyFolderSync(src, tgt);
+                    installedCount++;
+                }
+            }
+        }
+
+        if (installedCount > 0) {
+            console.log('\n✅ Installation completed successfully.');
+            if (selection['gsd-converter']) {
+                console.log('\n✨ To initialize the GSD engine, run:');
+                console.log('  py .agent/skills/gsd-converter/scripts/convert.py gsd\n');
+            }
+        } else {
+            console.log('\nℹ️  No skills were selected for installation.');
+        }
+
+    } catch (err) {
+        console.error('\n❌ Installation failed:', err.message);
+    } finally {
+        rl.close();
+    }
+}
+
+function copyFolderSync(from, to) {
+    if (!fs.existsSync(to)) {
+        fs.mkdirSync(to, { recursive: true });
+    }
+    fs.readdirSync(from).forEach(element => {
+        const srcPath = path.join(from, element);
+        const tgtPath = path.join(to, element);
+        const stat = fs.lstatSync(srcPath);
+        if (stat.isFile()) {
+            fs.copyFileSync(srcPath, tgtPath);
+        } else if (stat.isDirectory()) {
+            copyFolderSync(srcPath, tgtPath);
+        }
+    });
+}
+
+install();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-antigravity-kit",
-  "version": "1.32.0",
+  "version": "2.0.0",
   "description": "Installer for GSD-Antigravity skills",
   "main": "index.js",
   "files": [

package/.agent/skills/gsd/references/commands/gsd-set-profile.md

@@ -1,12 +0,0 @@
----
-name: gsd-set-profile
-description: "Switch model profile for GSD agents (quality/balanced/budget/inherit)"
-argument-hint: "<profile (quality|balanced|budget|inherit)>"
-allowed-tools:
-  - Bash
----
-
-
-Show the following output to the user verbatim, with no extra commentary:
-
-!`node ".agent/skills/gsd/bin/gsd-tools.cjs" config-set-model-profile $ARGUMENTS --raw`