gsd-antigravity-kit 1.32.0 → 2.0.0

package/.agent/skills/gsd/bin/lib/learnings.cjs

@@ -0,0 +1,378 @@
+/**
+ * Learnings — Global knowledge store with CRUD operations
+ *
+ * Provides a cross-project learnings store at ~/.gsd/knowledge/.
+ * Each learning is stored as an individual JSON file with content-hash
+ * deduplication. Supports write, read, list, query, delete, copy-from-project,
+ * and prune operations.
+ *
+ * Storage format: { id, source_project, date, context, learning, tags, content_hash }
+ * File naming: {id}.json
+ * Deduplication: SHA-256 of learning text + source_project
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const os = require('os');
+const { output, error: coreError } = require('./core.cjs');
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+const DEFAULT_STORE_DIR = path.join(os.homedir(), '.gsd', 'knowledge');
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+/**
+ * Get the store directory, allowing override for testing.
+ * @param {object} [opts]
+ * @param {string} [opts.storeDir] - Override store directory
+ * @returns {string}
+ */
+function getStoreDir(opts) {
+  return (opts && opts.storeDir) || DEFAULT_STORE_DIR;
+}
+
+/**
+ * Ensure the store directory exists. Created on first write, not on install.
+ * @param {string} dir
+ */
+function ensureStoreDir(dir) {
+  if (!fs.existsSync(dir)) {
+  fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+/**
+ * Generate a content hash for deduplication.
+ * Uses SHA-256 of learning text combined with source_project.
+ * @param {string} learning
+ * @param {string} sourceProject
+ * @returns {string}
+ */
+function contentHash(learning, sourceProject) {
+  return crypto.createHash('sha256')
+  .update(learning + '\n' + sourceProject)
+  .digest('hex');
+}
+
+/**
+ * Generate a unique ID based on timestamp + random suffix.
+ * @returns {string}
+ */
+function generateId() {
+  const ts = Date.now().toString(36);
+  const rand = crypto.randomBytes(4).toString('hex');
+  return `${ts}-${rand}`;
+}
+
+/**
+ * Read and parse a single learning JSON file.
+ * Returns null (with stderr warning) for malformed files.
+ * @param {string} filePath
+ * @returns {object|null}
+ */
+function readLearningFile(filePath) {
+  try {
+  const content = fs.readFileSync(filePath, 'utf-8');
+  return JSON.parse(content);
+  } catch (err) {
+  process.stderr.write(`Warning: skipping malformed file ${filePath}: ${err.message}\n`);
+  return null;
+  }
+}
+
+// ─── CRUD Operations ─────────────────────────────────────────────────────────
+
+/**
+ * Write a learning to the global store.
+ * Deduplicates by content hash — same content from same project is not stored twice.
+ *
+ * @param {object} entry
+ * @param {string} entry.source_project - Project name or path
+ * @param {string} entry.learning - The learning text
+ * @param {string} [entry.context] - Additional context
+ * @param {string[]} [entry.tags] - Tags for querying
+ * @param {object} [opts]
+ * @param {string} [opts.storeDir] - Override store directory
+ * @returns {{ id: string, created: boolean, content_hash: string }}
+ */
+function learningsWrite(entry, opts) {
+  const dir = getStoreDir(opts);
+  ensureStoreDir(dir);
+
+  const hash = contentHash(entry.learning, entry.source_project);
+
+  // Check for duplicate by scanning existing files
+  const files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
+  for (const file of files) {
+  const existing = readLearningFile(path.join(dir, file));
+  if (existing && existing.content_hash === hash) {
+    return { id: existing.id, created: false, content_hash: hash };
+  }
+  }
+
+  const id = generateId();
+  const record = {
+  id,
+  source_project: entry.source_project,
+  date: new Date().toISOString(),
+  context: entry.context || '',
+  learning: entry.learning,
+  tags: entry.tags || [],
+  content_hash: hash,
+  };
+
+  fs.writeFileSync(path.join(dir, `${id}.json`), JSON.stringify(record, null, 2), 'utf-8');
+  return { id, created: true, content_hash: hash };
+}
+
+/**
+ * Read a single learning by ID.
+ *
+ * @param {string} id
+ * @param {object} [opts]
+ * @param {string} [opts.storeDir] - Override store directory
+ * @returns {object|null}
+ */
+function learningsRead(id, opts) {
+  if (!/^[a-z0-9]+-[a-f0-9]+$/.test(id)) return null;
+  const dir = getStoreDir(opts);
+  const filePath = path.join(dir, `${id}.json`);
+  if (!fs.existsSync(filePath)) return null;
+  return readLearningFile(filePath);
+}
+
+/**
+ * List all learnings, sorted by date (newest first).
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.storeDir] - Override store directory
+ * @returns {object[]}
+ */
+function learningsList(opts) {
+  const dir = getStoreDir(opts);
+  if (!fs.existsSync(dir)) return [];
+
+  const files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
+  const results = [];
+  for (const file of files) {
+  const record = readLearningFile(path.join(dir, file));
+  if (record) results.push(record);
+  }
+
+  // Sort by date descending (newest first)
+  results.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
+  return results;
+}
+
+/**
+ * Query learnings by tag.
+ *
+ * @param {object} query
+ * @param {string} [query.tag] - Tag to filter by
+ * @param {object} [opts]
+ * @param {string} [opts.storeDir] - Override store directory
+ * @returns {object[]}
+ */
+function learningsQuery(query, opts) {
+  const all = learningsList(opts);
+  if (query && query.tag) {
+  return all.filter(r => r.tags && r.tags.includes(query.tag));
+  }
+  return all;
+}
+
+/**
+ * Delete a learning by ID.
+ *
+ * @param {string} id
+ * @param {object} [opts]
+ * @param {string} [opts.storeDir] - Override store directory
+ * @returns {boolean} true if deleted, false if not found
+ */
+function learningsDelete(id, opts) {
+  if (!/^[a-z0-9]+-[a-f0-9]+$/.test(id)) return false;
+  const dir = getStoreDir(opts);
+  const filePath = path.join(dir, `${id}.json`);
+  if (!fs.existsSync(filePath)) return false;
+  fs.unlinkSync(filePath);
+  return true;
+}
+
+/**
+ * Copy learnings from a project's LEARNINGS.md into the global store.
+ * Parses markdown sections as individual learnings. Deduplicates by content hash.
+ *
+ * Expected LEARNINGS.md format:
+ *   ## Section Title
+ *   Learning content paragraph(s)...
+ *
+ *   ## Another Section
+ *   More content...
+ *
+ * @param {string} planningDir - Path to .planning/ directory (or directory containing LEARNINGS.md)
+ * @param {object} [opts]
+ * @param {string} [opts.storeDir] - Override store directory
+ * @param {string} [opts.sourceProject] - Project name (defaults to directory basename)
+ * @returns {{ total: number, created: number, skipped: number }}
+ */
+function learningsCopyFromProject(planningDir, opts) {
+  const learningsPath = path.join(planningDir, 'LEARNINGS.md');
+  if (!fs.existsSync(learningsPath)) {
+  return { total: 0, created: 0, skipped: 0 };
+  }
+
+  const content = fs.readFileSync(learningsPath, 'utf-8');
+  const sourceProject = (opts && opts.sourceProject) || path.basename(path.resolve(planningDir, '..'));
+
+  // Parse markdown: split on ## headings
+  const sections = content.split(/^## /m).slice(1); // skip preamble before first ##
+  let created = 0;
+  let skipped = 0;
+
+  for (const section of sections) {
+  const lines = section.trim().split('\n');
+  const title = lines[0].trim();
+  const body = lines.slice(1).join('\n').trim();
+  if (!body) continue;
+
+  // Extract tags from title (simple: use words as tags)
+  const tags = title.toLowerCase().split(/\s+/).filter(w => w.length > 2);
+
+  const result = learningsWrite({
+    source_project: sourceProject,
+    learning: body,
+    context: title,
+    tags,
+  }, opts);
+
+  if (result.created) {
+    created++;
+  } else {
+    skipped++;
+  }
+  }
+
+  return { total: created + skipped, created, skipped };
+}
+
+/**
+ * Prune learnings older than a given threshold.
+ *
+ * @param {string} olderThan - Duration string like "90d", "30d", "7d"
+ * @param {object} [opts]
+ * @param {string} [opts.storeDir] - Override store directory
+ * @returns {{ removed: number, kept: number }}
+ */
+function learningsPrune(olderThan, opts) {
+  const match = /^(\d+)d$/.exec(olderThan);
+  if (!match) {
+  throw new Error(`Invalid duration format: "${olderThan}" — expected format like "90d"`);
+  }
+
+  const days = parseInt(match[1], 10);
+  const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+  const dir = getStoreDir(opts);
+
+  if (!fs.existsSync(dir)) return { removed: 0, kept: 0 };
+
+  const files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
+  let removed = 0;
+  let kept = 0;
+
+  for (const file of files) {
+  const filePath = path.join(dir, file);
+  const record = readLearningFile(filePath);
+  if (!record) continue;
+
+  const recordDate = new Date(record.date);
+  if (recordDate < cutoff) {
+    fs.unlinkSync(filePath);
+    removed++;
+  } else {
+    kept++;
+  }
+  }
+
+  return { removed, kept };
+}
+
+// ─── CLI Command Handlers ────────────────────────────────────────────────────
+
+/**
+ * Handle `gsd-tools learnings list`
+ * @param {boolean} raw - Raw output flag
+ */
+function cmdLearningsList(raw) {
+  const results = learningsList();
+  output({ learnings: results, count: results.length }, raw);
+}
+
+/**
+ * Handle `gsd-tools learnings query --tag <tag>`
+ * @param {string} tag
+ * @param {boolean} raw - Raw output flag
+ */
+function cmdLearningsQuery(tag, raw) {
+  const results = learningsQuery({ tag });
+  output({ learnings: results, count: results.length, tag }, raw);
+}
+
+/**
+ * Handle `gsd-tools learnings copy`
+ * @param {string} cwd - Current working directory
+ * @param {boolean} raw - Raw output flag
+ */
+function cmdLearningsCopy(cwd, raw) {
+  const planningDir = path.join(cwd, '.planning');
+  const result = learningsCopyFromProject(planningDir);
+  output(result, raw);
+}
+
+/**
+ * Handle `gsd-tools learnings prune --older-than <duration>`
+ * @param {string} olderThan - Duration string like "90d"
+ * @param {boolean} raw - Raw output flag
+ */
+function cmdLearningsPrune(olderThan, raw) {
+  try {
+  const result = learningsPrune(olderThan);
+  output(result, raw);
+  } catch (err) {
+  coreError(err.message);
+  }
+}
+
+/**
+ * Handle `gsd-tools learnings delete <id>`
+ * @param {string} id
+ * @param {boolean} raw - Raw output flag
+ */
+function cmdLearningsDelete(id, raw) {
+  if (!/^[a-z0-9]+-[a-f0-9]+$/.test(id)) {
+  coreError(`Invalid learning ID: "${id}"`);
+  }
+  const deleted = learningsDelete(id);
+  output({ id, deleted }, raw);
+}
+
+// ─── Exports ─────────────────────────────────────────────────────────────────
+
+module.exports = {
+  learningsWrite,
+  learningsRead,
+  learningsList,
+  learningsQuery,
+  learningsDelete,
+  learningsCopyFromProject,
+  learningsPrune,
+  cmdLearningsList,
+  cmdLearningsQuery,
+  cmdLearningsCopy,
+  cmdLearningsPrune,
+  cmdLearningsDelete,
+  DEFAULT_STORE_DIR,
+};

package/.agent/skills/gsd/bin/lib/milestone.cjs

@@ -246,15 +246,24 @@ function cmdMilestoneComplete(cwd, version, options, raw) {
   output(result, raw);
 }
 
-function cmdPhasesClear(cwd, raw) {
+function cmdPhasesClear(cwd, raw, args) {
   const phasesDir = planningPaths(cwd).phases;
+  const confirm = Array.isArray(args) && args.includes('--confirm');
   let cleared = 0;
 
   if (fs.existsSync(phasesDir)) {
+  const entries = fs.readdirSync(phasesDir, { withFileTypes: true });
+  const dirs = entries.filter(e => e.isDirectory() && !/^999(?:\.|$)/.test(e.name));
+
+  if (dirs.length > 0 && !confirm) {
+    error(
+    `phases clear would delete ${dirs.length} phase director${dirs.length === 1 ? 'y' : 'ies'}. ` +
+    `Pass --confirm to proceed.`
+    );
+  }
+
   try {
-    const entries = fs.readdirSync(phasesDir, { withFileTypes: true });
-    for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
+    for (const entry of dirs) {
     fs.rmSync(path.join(phasesDir, entry.name), { recursive: true, force: true });
     cleared++;
     }

package/.agent/skills/gsd/bin/lib/model-profiles.cjs

@@ -7,23 +7,23 @@
  * would be faster, use fewer tokens, and be less error-prone).
  */
 const MODEL_PROFILES = {
-  'gsd-planner': { quality: 'opus', balanced: 'opus', budget: 'sonnet' },
-  'gsd-roadmapper': { quality: 'opus', balanced: 'sonnet', budget: 'sonnet' },
-  'gsd-executor': { quality: 'opus', balanced: 'sonnet', budget: 'sonnet' },
-  'gsd-phase-researcher': { quality: 'opus', balanced: 'sonnet', budget: 'haiku' },
-  'gsd-project-researcher': { quality: 'opus', balanced: 'sonnet', budget: 'haiku' },
-  'gsd-research-synthesizer': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku' },
-  'gsd-debugger': { quality: 'opus', balanced: 'sonnet', budget: 'sonnet' },
-  'gsd-codebase-mapper': { quality: 'sonnet', balanced: 'haiku', budget: 'haiku' },
-  'gsd-verifier': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku' },
-  'gsd-plan-checker': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku' },
-  'gsd-integration-checker': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku' },
-  'gsd-nyquist-auditor': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku' },
-  'gsd-ui-researcher': { quality: 'opus', balanced: 'sonnet', budget: 'haiku' },
-  'gsd-ui-checker': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku' },
-  'gsd-ui-auditor': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku' },
-  'gsd-doc-writer': { quality: 'opus', balanced: 'sonnet', budget: 'haiku' },
-  'gsd-doc-verifier': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku' },
+  'gsd-planner': { quality: 'opus', balanced: 'opus', budget: 'sonnet', adaptive: 'opus' },
+  'gsd-roadmapper': { quality: 'opus', balanced: 'sonnet', budget: 'sonnet', adaptive: 'sonnet' },
+  'gsd-executor': { quality: 'opus', balanced: 'sonnet', budget: 'sonnet', adaptive: 'sonnet' },
+  'gsd-phase-researcher': { quality: 'opus', balanced: 'sonnet', budget: 'haiku', adaptive: 'sonnet' },
+  'gsd-project-researcher': { quality: 'opus', balanced: 'sonnet', budget: 'haiku', adaptive: 'sonnet' },
+  'gsd-research-synthesizer': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku', adaptive: 'haiku' },
+  'gsd-debugger': { quality: 'opus', balanced: 'sonnet', budget: 'sonnet', adaptive: 'opus' },
+  'gsd-codebase-mapper': { quality: 'sonnet', balanced: 'haiku', budget: 'haiku', adaptive: 'haiku' },
+  'gsd-verifier': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku', adaptive: 'sonnet' },
+  'gsd-plan-checker': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku', adaptive: 'haiku' },
+  'gsd-integration-checker': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku', adaptive: 'haiku' },
+  'gsd-nyquist-auditor': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku', adaptive: 'haiku' },
+  'gsd-ui-researcher': { quality: 'opus', balanced: 'sonnet', budget: 'haiku', adaptive: 'sonnet' },
+  'gsd-ui-checker': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku', adaptive: 'haiku' },
+  'gsd-ui-auditor': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku', adaptive: 'haiku' },
+  'gsd-doc-writer': { quality: 'opus', balanced: 'sonnet', budget: 'haiku', adaptive: 'sonnet' },
+  'gsd-doc-verifier': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku', adaptive: 'haiku' },
 };
 const VALID_PROFILES = Object.keys(MODEL_PROFILES['gsd-planner']);
 

package/.agent/skills/gsd/bin/lib/profile-output.cjs

@@ -121,7 +121,7 @@ const PROFILING_QUESTIONS = [
   },
 ];
 
-const CLAUDE_INSTRUCTIONS = {
+const ANTIGRAVITY_INSTRUCTIONS = {
   communication_style: {
   'terse-direct': 'Keep responses concise and action-oriented. Skip lengthy preambles. Match this developer\'s direct style.',
   'conversational': 'Use a natural conversational tone. Explain reasoning briefly alongside code. Engage with the developer\'s questions.',
@@ -172,7 +172,7 @@ const CLAUDE_INSTRUCTIONS = {
   },
 };
 
-const CLAUDE_MD_FALLBACKS = {
+const ANTIGRAVITY_MD_FALLBACKS = {
   project: 'Project not yet initialized. Run /gsd-new-project to set up.',
   stack: 'Technology stack not yet documented. Will populate after codebase mapping or first phase.',
   conventions: 'Conventions not yet established. Will populate as patterns emerge during development.',
@@ -183,7 +183,7 @@ const CLAUDE_MD_FALLBACKS = {
 // Directories where project skills may live (checked in order)
 const SKILL_SEARCH_DIRS = ['.antigravity/skills', '.agents/skills', '.cursor/skills', '.github/skills'];
 
-const CLAUDE_MD_WORKFLOW_ENFORCEMENT = [
+const ANTIGRAVITY_MD_WORKFLOW_ENFORCEMENT = [
   'Before using Edit, Write, or other file-changing tools, start work through a GSD command so planning artifacts and execution context stay in sync.',
   '',
   'Use these entry points:',
@@ -194,7 +194,7 @@ const CLAUDE_MD_WORKFLOW_ENFORCEMENT = [
   'Do not make direct repo edits outside a GSD workflow unless the user explicitly asks to bypass it.',
 ].join('\n');
 
-const CLAUDE_MD_PROFILE_PLACEHOLDER = [
+const ANTIGRAVITY_MD_PROFILE_PLACEHOLDER = [
   '<!-- GSD:profile-start -->',
   '## Developer Profile',
   '',
@@ -214,8 +214,8 @@ function isAmbiguousAnswer(dimension, value) {
   return option.rating === 'mixed';
 }
 
-function generateClaudeInstruction(dimension, rating) {
-  const dimInstructions = CLAUDE_INSTRUCTIONS[dimension];
+function generateAntigravityInstruction(dimension, rating) {
+  const dimInstructions = ANTIGRAVITY_INSTRUCTIONS[dimension];
   if (dimInstructions && dimInstructions[rating]) {
   return dimInstructions[rating];
   }
@@ -285,7 +285,7 @@ function generateProjectSection(cwd) {
   const projectPath = path.join(cwd, '.planning', 'PROJECT.md');
   const content = safeReadFile(projectPath);
   if (!content) {
-  return { content: CLAUDE_MD_FALLBACKS.project, source: 'PROJECT.md', hasFallback: true };
+  return { content: ANTIGRAVITY_MD_FALLBACKS.project, source: 'PROJECT.md', hasFallback: true };
   }
   const parts = [];
   const h1Match = content.match(/^# (.+)$/m);
@@ -306,7 +306,7 @@ function generateProjectSection(cwd) {
   if (body) parts.push(`### Constraints\n\n${body}`);
   }
   if (parts.length === 0) {
-  return { content: CLAUDE_MD_FALLBACKS.project, source: 'PROJECT.md', hasFallback: true };
+  return { content: ANTIGRAVITY_MD_FALLBACKS.project, source: 'PROJECT.md', hasFallback: true };
   }
   return { content: parts.join('\n\n'), source: 'PROJECT.md', hasFallback: false };
 }
@@ -321,7 +321,7 @@ function generateStackSection(cwd) {
   source = 'research/STACK.md';
   }
   if (!content) {
-  return { content: CLAUDE_MD_FALLBACKS.stack, source: 'STACK.md', hasFallback: true };
+  return { content: ANTIGRAVITY_MD_FALLBACKS.stack, source: 'STACK.md', hasFallback: true };
   }
   const lines = content.split('\n');
   const summaryLines = [];
@@ -343,7 +343,7 @@ function generateConventionsSection(cwd) {
   const conventionsPath = path.join(cwd, '.planning', 'codebase', 'CONVENTIONS.md');
   const content = safeReadFile(conventionsPath);
   if (!content) {
-  return { content: CLAUDE_MD_FALLBACKS.conventions, source: 'CONVENTIONS.md', hasFallback: true };
+  return { content: ANTIGRAVITY_MD_FALLBACKS.conventions, source: 'CONVENTIONS.md', hasFallback: true };
   }
   const lines = content.split('\n');
   const summaryLines = [];
@@ -359,7 +359,7 @@ function generateArchitectureSection(cwd) {
   const architecturePath = path.join(cwd, '.planning', 'codebase', 'ARCHITECTURE.md');
   const content = safeReadFile(architecturePath);
   if (!content) {
-  return { content: CLAUDE_MD_FALLBACKS.architecture, source: 'ARCHITECTURE.md', hasFallback: true };
+  return { content: ANTIGRAVITY_MD_FALLBACKS.architecture, source: 'ARCHITECTURE.md', hasFallback: true };
   }
   const lines = content.split('\n');
   const summaryLines = [];
@@ -373,7 +373,7 @@ function generateArchitectureSection(cwd) {
 
 function generateWorkflowSection() {
   return {
-  content: CLAUDE_MD_WORKFLOW_ENFORCEMENT,
+  content: ANTIGRAVITY_MD_WORKFLOW_ENFORCEMENT,
   source: 'GSD defaults',
   hasFallback: false,
   };
@@ -421,7 +421,7 @@ function generateSkillsSection(cwd) {
   }
 
   if (discovered.length === 0) {
-  return { content: CLAUDE_MD_FALLBACKS.skills, source: 'skills/', hasFallback: true };
+  return { content: ANTIGRAVITY_MD_FALLBACKS.skills, source: 'skills/', hasFallback: true };
   }
 
   const lines = ['| Skill | Description | Path |', '|-------|-------------|------|'];
@@ -565,10 +565,10 @@ function cmdWriteProfile(cwd, options, raw) {
   if (conf === 'HIGH' || conf === 'MEDIUM' || conf === 'LOW') dimensionsScored++;
   if (conf === 'HIGH') {
     highCount++;
-    if (dim.claude_instruction) summaryLines.push(`- **${dimensionLabels[dimKey] || dimKey}:** ${dim.claude_instruction} (HIGH)`);
+    if (dim.antigravity_instruction) summaryLines.push(`- **${dimensionLabels[dimKey] || dimKey}:** ${dim.antigravity_instruction} (HIGH)`);
   } else if (conf === 'MEDIUM') {
     mediumCount++;
-    if (dim.claude_instruction) summaryLines.push(`- **${dimensionLabels[dimKey] || dimKey}:** ${dim.claude_instruction} (MEDIUM)`);
+    if (dim.antigravity_instruction) summaryLines.push(`- **${dimensionLabels[dimKey] || dimKey}:** ${dim.antigravity_instruction} (MEDIUM)`);
   } else if (conf === 'LOW') {
     lowCount++;
   }
@@ -596,7 +596,7 @@ function cmdWriteProfile(cwd, options, raw) {
   const dim = analysis.dimensions[dimKey] || {};
   const rating = dim.rating || 'UNSCORED';
   const confidence = dim.confidence || 'UNSCORED';
-  const instruction = dim.claude_instruction || 'No strong preference detected. Ask the developer when this dimension is relevant.';
+  const instruction = dim.antigravity_instruction || 'No strong preference detected. Ask the developer when this dimension is relevant.';
   const summary = dim.summary || '';
 
   let evidenceBlock = '';
@@ -615,7 +615,7 @@ function cmdWriteProfile(cwd, options, raw) {
 
   template = template.replace(new RegExp(`\\{\\{${dimKey}\\.rating\\}\\}`, 'g'), rating);
   template = template.replace(new RegExp(`\\{\\{${dimKey}\\.confidence\\}\\}`, 'g'), confidence);
-  template = template.replace(new RegExp(`\\{\\{${dimKey}\\.claude_instruction\\}\\}`, 'g'), instruction);
+  template = template.replace(new RegExp(`\\{\\{${dimKey}\\.antigravity_instruction\\}\\}`, 'g'), instruction);
   template = template.replace(new RegExp(`\\{\\{${dimKey}\\.summary\\}\\}`, 'g'), summary);
   template = template.replace(new RegExp(`\\{\\{${dimKey}\\.evidence\\}\\}`, 'g'), evidenceBlock);
   }
@@ -697,7 +697,7 @@ function cmdProfileQuestionnaire(options, raw) {
     project: 'N/A (questionnaire)',
     }],
     summary: `Developer self-reported as ${selectedOption.rating} for ${question.header.toLowerCase()}.`,
-    claude_instruction: generateClaudeInstruction(question.dimension, selectedOption.rating),
+    antigravity_instruction: generateAntigravityInstruction(question.dimension, selectedOption.rating),
   };
   }
 
@@ -745,9 +745,9 @@ function cmdGenerateDevPreferences(cwd, options, raw) {
   if (!dim) continue;
   const label = devPrefLabels[dimKey] || dimKey;
   const confidence = dim.confidence || 'UNSCORED';
-  let instruction = dim.claude_instruction;
+  let instruction = dim.antigravity_instruction;
   if (!instruction) {
-    const lookup = CLAUDE_INSTRUCTIONS[dimKey];
+    const lookup = ANTIGRAVITY_INSTRUCTIONS[dimKey];
     if (lookup && dim.rating && lookup[dim.rating]) {
     instruction = lookup[dim.rating];
     } else {
@@ -793,7 +793,7 @@ function cmdGenerateDevPreferences(cwd, options, raw) {
   output(result, raw);
 }
 
-function cmdGenerateClaudeProfile(cwd, options, raw) {
+function cmdGenerateAntigravityProfile(cwd, options, raw) {
   if (!options.analysis) error('--analysis <path> is required');
 
   let analysisPath = options.analysis;
@@ -834,9 +834,9 @@ function cmdGenerateClaudeProfile(cwd, options, raw) {
   const rating = dim.rating || 'UNSCORED';
   const confidence = dim.confidence || 'UNSCORED';
   tableRows.push(`| ${label} | ${rating} | ${confidence} |`);
-  let instruction = dim.claude_instruction;
+  let instruction = dim.antigravity_instruction;
   if (!instruction) {
-    const lookup = CLAUDE_INSTRUCTIONS[dimKey];
+    const lookup = ANTIGRAVITY_INSTRUCTIONS[dimKey];
     if (lookup && dim.rating && lookup[dim.rating]) {
     instruction = lookup[dim.rating];
     } else {
@@ -899,7 +899,7 @@ function cmdGenerateClaudeProfile(cwd, options, raw) {
   }
 
   const result = {
-  claude_md_path: targetPath,
+  antigravity_md_path: targetPath,
   action,
   dimensions_included: dimensionsIncluded,
   is_global: !!options.global,
@@ -908,7 +908,7 @@ function cmdGenerateClaudeProfile(cwd, options, raw) {
   output(result, raw);
 }
 
-function cmdGenerateClaudeMd(cwd, options, raw) {
+function cmdGenerateAntigravityMd(cwd, options, raw) {
   const MANAGED_SECTIONS = ['project', 'stack', 'conventions', 'architecture', 'skills', 'workflow'];
   const generators = {
   project: generateProjectSection,
@@ -961,7 +961,7 @@ function cmdGenerateClaudeMd(cwd, options, raw) {
     sections.push(buildSection(name, gen.source, body));
   }
   sections.push('');
-  sections.push(CLAUDE_MD_PROFILE_PLACEHOLDER);
+  sections.push(ANTIGRAVITY_MD_PROFILE_PLACEHOLDER);
   existingContent = sections.join('\n\n') + '\n';
   action = 'created';
   fs.mkdirSync(path.dirname(outputPath), { recursive: true });
@@ -998,7 +998,7 @@ function cmdGenerateClaudeMd(cwd, options, raw) {
   }
 
   if (!options.auto && fileContent.indexOf('<!-- GSD:profile-start') === -1) {
-    fileContent = fileContent.trimEnd() + '\n\n' + CLAUDE_MD_PROFILE_PLACEHOLDER + '\n';
+    fileContent = fileContent.trimEnd() + '\n\n' + ANTIGRAVITY_MD_PROFILE_PLACEHOLDER + '\n';
   }
 
   fs.writeFileSync(outputPath, fileContent, 'utf-8');
@@ -1024,7 +1024,7 @@ function cmdGenerateClaudeMd(cwd, options, raw) {
   if (profileStatus === 'placeholder_added') message += ' Run /gsd-profile-user to unlock Developer Profile.';
 
   const result = {
-  claude_md_path: outputPath,
+  antigravity_md_path: outputPath,
   action,
   sections_generated: sectionsGenerated,
   sections_fallback: sectionsFallback,
@@ -1041,8 +1041,8 @@ module.exports = {
   cmdWriteProfile,
   cmdProfileQuestionnaire,
   cmdGenerateDevPreferences,
-  cmdGenerateClaudeProfile,
-  cmdGenerateClaudeMd,
+  cmdGenerateAntigravityProfile,
+  cmdGenerateAntigravityMd,
   PROFILING_QUESTIONS,
-  CLAUDE_INSTRUCTIONS,
+  ANTIGRAVITY_INSTRUCTIONS,
 };