legacyver 2.1.3 → 2.1.5

package/src/db/index.js

@@ -0,0 +1,145 @@
+'use strict';
+
+const { Pool } = require('pg');
+const path = require('path');
+const dbConfig = require('./config');
+const { loadSession } = require('../utils/config');
+const logger = require('../utils/logger');
+
+let _pool = null;
+
+/**
+ * Lazy singleton pool — created on first use, ended after push.
+ */
+function getPool() {
+  if (!_pool) {
+    _pool = new Pool(dbConfig);
+  }
+  return _pool;
+}
+
+/**
+ * Find or create a repository for the given user + project path.
+ * @param {Pool} pool
+ * @param {string} userId  UUID
+ * @param {string} projectPath  absolute path of the analyzed directory
+ * @returns {Promise<string>} repository id (UUID)
+ */
+async function getOrCreateRepo(pool, userId, projectPath) {
+  const name = path.basename(projectPath);
+  const fullName = projectPath;
+
+  // Try find existing
+  const existing = await pool.query(
+    'SELECT id FROM repositories WHERE user_id = $1 AND full_name = $2',
+    [userId, fullName]
+  );
+  if (existing.rows.length > 0) {
+    return existing.rows[0].id;
+  }
+
+  // Insert new
+  const inserted = await pool.query(
+    'INSERT INTO repositories (user_id, name, full_name) VALUES ($1, $2, $3) RETURNING id',
+    [userId, name, fullName]
+  );
+  return inserted.rows[0].id;
+}
+
+/**
+ * Find or create a documentation record for a repository.
+ * One documentation per repository (title = repo name).
+ * @param {Pool} pool
+ * @param {string} repositoryId  UUID
+ * @param {string} repoName
+ * @returns {Promise<string>} documentation id (UUID)
+ */
+async function getOrCreateDocumentation(pool, repositoryId, repoName) {
+  const existing = await pool.query(
+    'SELECT id FROM documentations WHERE repository_id = $1',
+    [repositoryId]
+  );
+  if (existing.rows.length > 0) {
+    return existing.rows[0].id;
+  }
+
+  const inserted = await pool.query(
+    'INSERT INTO documentations (repository_id, title, description) VALUES ($1, $2, $3) RETURNING id',
+    [repositoryId, `${repoName} Documentation`, `Auto-generated documentation for ${repoName}`]
+  );
+  return inserted.rows[0].id;
+}
+
+/**
+ * Upsert documentation pages.
+ * Each fragment becomes a page; slug = file path, title = file name.
+ * Uses (documentation_id, slug) as the logical unique key.
+ * @param {Pool} pool
+ * @param {string} documentationId  UUID
+ * @param {Array<{relativePath: string, content: string}>} fragments
+ * @returns {Promise<number>} count of upserted pages
+ */
+async function upsertPages(pool, documentationId, fragments) {
+  let count = 0;
+  for (let i = 0; i < fragments.length; i++) {
+    const frag = fragments[i];
+    const slug = frag.relativePath.replace(/\\/g, '/');
+    const title = path.basename(frag.relativePath);
+
+    // Check if page exists
+    const existing = await pool.query(
+      'SELECT id FROM documentation_pages WHERE documentation_id = $1 AND slug = $2',
+      [documentationId, slug]
+    );
+
+    if (existing.rows.length > 0) {
+      // Update existing
+      await pool.query(
+        'UPDATE documentation_pages SET content = $1, title = $2, page_order = $3, created_at = NOW() WHERE id = $4',
+        [frag.content, title, i + 1, existing.rows[0].id]
+      );
+    } else {
+      // Insert new
+      await pool.query(
+        'INSERT INTO documentation_pages (documentation_id, slug, title, content, page_order) VALUES ($1, $2, $3, $4, $5)',
+        [documentationId, slug, title, frag.content, i + 1]
+      );
+    }
+    count++;
+  }
+  return count;
+}
+
+/**
+ * Top-level push function. Called from analyze command.
+ * Short-circuits if user is not logged in.
+ * @param {Array<{relativePath: string, content: string}>} fragments
+ * @param {string} projectPath  absolute path of the analyzed directory
+ * @param {object} [opts]          optional overrides for testing
+ * @param {object} [opts.pool]     pg Pool instance (skips singleton pool)
+ * @param {object} [opts.session]  session object (skips loadSession)
+ * @returns {Promise<{skipped: boolean, pushed?: number}>}
+ */
+async function pushToDatabase(fragments, projectPath, opts) {
+  const session = (opts && opts.session) || loadSession();
+  if (!session.userId) {
+    return { skipped: true };
+  }
+
+  const ownPool = !(opts && opts.pool);
+  const pool = (opts && opts.pool) || getPool();
+  try {
+    const repoName = path.basename(projectPath);
+    const repoId = await getOrCreateRepo(pool, session.userId, projectPath);
+    const docId = await getOrCreateDocumentation(pool, repoId, repoName);
+    const pushed = await upsertPages(pool, docId, fragments);
+    return { skipped: false, pushed };
+  } finally {
+    if (ownPool) {
+      await pool.end().catch(() => {});
+      _pool = null;
+    }
+  }
+}
+
+module.exports = { getPool, getOrCreateRepo, getOrCreateDocumentation, upsertPages, pushToDatabase };

package/src/llm/free-model.js

@@ -9,10 +9,10 @@ const pc = require('picocolors');
  * @returns {Object} mutated config
  */
 function applyFreeModelPolicy(config) {
-  const provider = (config.provider || 'openrouter').toLowerCase();
+  const provider = (config.provider || 'groq').toLowerCase();
 
-  // Ollama, Groq, and Gemini are always free — skip openrouter-specific logic
-  if (provider === 'ollama' || provider === 'groq' || provider === 'gemini') {
+  // Ollama, Groq, Gemini, and Kimi are always free — skip openrouter-specific logic
+  if (provider === 'ollama' || provider === 'groq' || provider === 'gemini' || provider === 'kimi') {
     config.isFreeModel = true;
     config.skipCostEstimation = true;
     if (provider === 'groq') {
@@ -33,6 +33,15 @@ function applyFreeModelPolicy(config) {
         config.concurrency = 2;
       }
     }
+    if (provider === 'kimi') {
+      console.log(pc.cyan('[info] Using Kimi (Moonshot AI) — free credits. Rate limit: 3 req/min'));
+      // Cap concurrency to 1 for Kimi (conservative rate limit)
+      const requested = parseInt(config.concurrency) || 1;
+      if (requested > 1) {
+        logger.warn(`Kimi free tier: capping concurrency from ${requested} to 1.`);
+        config.concurrency = 1;
+      }
+    }
     return config;
   }
 

package/src/llm/index.js

@@ -4,24 +4,27 @@ const { OpenRouterProvider } = require('./providers/openrouter');
 const { OllamaProvider } = require('./providers/ollama');
 const { GroqProvider } = require('./providers/groq');
 const { GeminiProvider } = require('./providers/gemini');
+const { KimiProvider } = require('./providers/kimi');
 
 /**
  * Provider factory — returns the appropriate LLM adapter.
  * @param {Object} config
- * @returns {OpenRouterProvider|OllamaProvider|GroqProvider|GeminiProvider}
+ * @returns {OpenRouterProvider|OllamaProvider|GroqProvider|GeminiProvider|KimiProvider}
  */
 function createProvider(config) {
-  const provider = (config.provider || 'openrouter').toLowerCase();
+  const provider = (config.provider || 'groq').toLowerCase();
   switch (provider) {
+    case 'openrouter':
+      return new OpenRouterProvider(config);
     case 'ollama':
       return new OllamaProvider(config);
-    case 'groq':
-      return new GroqProvider(config);
     case 'gemini':
       return new GeminiProvider(config);
-    case 'openrouter':
+    case 'kimi':
+      return new KimiProvider(config);
+    case 'groq':
     default:
-      return new OpenRouterProvider(config);
+      return new GroqProvider(config);
   }
 }
 

package/src/llm/providers/groq.js

@@ -4,10 +4,12 @@ const { NoApiKeyError } = require('../../utils/errors');
 
 const GROQ_BASE = 'https://api.groq.com/openai/v1';
 const DEFAULT_MODEL = 'llama-3.3-70b-versatile';
-
+// Built-in shared key — lets users run legacyver out of the box without setup.
+// Users can override with their own GROQ_API_KEY env var for higher rate limits.
+const BUILT_IN_KEY = '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';
 class GroqProvider {
   constructor(config) {
-    this.apiKey = process.env.GROQ_API_KEY || config.groqApiKey;
+    this.apiKey = process.env.GROQ_API_KEY || config.groqApiKey || BUILT_IN_KEY;
     if (!this.apiKey) throw new NoApiKeyError('groq');
     this.model = config.model || DEFAULT_MODEL;
     this.name = 'groq';

package/src/llm/providers/kimi.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const { NoApiKeyError } = require('../../utils/errors');
+
+const KIMI_BASE = 'https://api.moonshot.cn/v1';
+const DEFAULT_MODEL = 'moonshot-v1-8k';
+
+class KimiProvider {
+  constructor(config) {
+    this.apiKey = process.env.MOONSHOT_API_KEY || config.kimiApiKey;
+    if (!this.apiKey) throw new NoApiKeyError('kimi');
+    this.model = config.model || DEFAULT_MODEL;
+    this.name = 'kimi';
+    this.isFreeModel = true; // Kimi free credits on sign-up
+  }
+
+  async complete(chunk) {
+    const body = {
+      model: this.model,
+      messages: [
+        { role: 'system', content: chunk.systemPrompt },
+        { role: 'user', content: chunk.userMessage },
+      ],
+      temperature: 0.3,
+    };
+
+    let response;
+    try {
+      response = await fetch(`${KIMI_BASE}/chat/completions`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.apiKey}`,
+        },
+        body: JSON.stringify(body),
+      });
+    } catch (e) {
+      throw new Error(`Could not connect to Kimi (Moonshot) API: ${e.message}`);
+    }
+
+    if (response.status === 429) {
+      const { RateLimitError } = require('../../utils/errors');
+      const headerVal = parseInt(response.headers.get('retry-after') || '0');
+      // Kimi rate limits are moderate; 10s minimum wait
+      const retryAfter = Math.max(headerVal * 1000, 10000);
+      const err = new RateLimitError('kimi', retryAfter);
+      try {
+        const text = await response.text();
+        const parsed = JSON.parse(text);
+        const detail = parsed.error && parsed.error.message ? parsed.error.message : text.substring(0, 200);
+        err.message = `Rate limit exceeded for provider "kimi": ${detail}`;
+      } catch (_) {
+        // keep default message
+      }
+      throw err;
+    }
+
+    if (response.status === 401) {
+      const text = await response.text();
+      throw new Error(
+        `Kimi API authentication failed (401). Check your MOONSHOT_API_KEY.\n` +
+        `Get a key at: https://platform.moonshot.cn/console/api-keys\n` +
+        `Detail: ${text.substring(0, 300)}`
+      );
+    }
+
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Kimi API error ${response.status}: ${text.substring(0, 500)}`);
+    }
+
+    const data = await response.json();
+    const content = (data.choices && data.choices[0] && data.choices[0].message && data.choices[0].message.content) || '';
+    const usage = data.usage || {};
+    const tokensUsed = {
+      input: usage.prompt_tokens || 0,
+      output: usage.completion_tokens || 0,
+    };
+
+    return { content, tokensUsed };
+  }
+
+  estimateCost() { return 0; }
+}
+
+module.exports = { KimiProvider };

package/src/llm/validator.js

@@ -40,7 +40,7 @@ function validateFragment(fragment, fileFacts) {
   for (const exp of (fileFacts.exports || [])) knownIdentifiers.add(exp);
 
   // Common words to skip (not identifiers)
-  const stopWords = new Set(['The', 'This', 'File', 'Function', 'Class', 'Method', 'Returns', 'Return', 'Parameter', 'Param', 'Import', 'Export', 'Overview', 'Usage', 'Example', 'Dependencies', 'Async', 'Static', 'Public', 'Private', 'Protected', 'Boolean', 'String', 'Number', 'Object', 'Array', 'Void', 'Null', 'Undefined', 'True', 'False', 'Error', 'Promise', 'Request', 'Response', 'Node', 'JavaScript', 'TypeScript', 'PHP', 'Python', 'Laravel', 'Express', 'Route', 'Controller', 'Model', 'Service', 'Repository', 'Middleware', 'Provider', 'Summary']);
+  const stopWords = new Set(['The', 'This', 'File', 'Function', 'Functions', 'Class', 'Method', 'Returns', 'Return', 'Parameter', 'Parameters', 'Param', 'Import', 'Export', 'Overview', 'Usage', 'Example', 'Dependencies', 'Dependency', 'Async', 'Static', 'Public', 'Private', 'Protected', 'Boolean', 'String', 'Number', 'Object', 'Array', 'Void', 'Null', 'Undefined', 'True', 'False', 'Error', 'Promise', 'Request', 'Response', 'Node', 'JavaScript', 'TypeScript', 'PHP', 'Python', 'Laravel', 'Express', 'Route', 'Controller', 'Model', 'Service', 'Repository', 'Middleware', 'Provider', 'Summary', 'None', 'Name', 'Description', 'Value', 'Type', 'Map', 'Set', 'Date', 'Creates', 'Create', 'Retrieves', 'Retrieve', 'Updates', 'Update', 'Deletes', 'Delete', 'Validates', 'Validate', 'Destroys', 'Destroy', 'Returns', 'Return', 'Gets', 'Get', 'Sets', 'Set', 'Checks', 'Check', 'Handles', 'Handle', 'Builds', 'Build', 'Loads', 'Load', 'Saves', 'Save', 'Sends', 'Send', 'Reads', 'Read', 'Writes', 'Write', 'Parses', 'Parse', 'Formats', 'Format', 'Converts', 'Convert', 'Generates', 'Generate', 'Initializes', 'Initialize', 'Registers', 'Register', 'Removes', 'Remove', 'Adds', 'Add', 'Lists', 'List', 'Fetches', 'Fetch', 'Renders', 'Render', 'Runs', 'Run', 'Starts', 'Start', 'Stops', 'Stop', 'Optional', 'Required', 'Default', 'Properties', 'Methods', 'Fields', 'Attributes', 'Throws', 'Emits', 'For', 'With', 'From', 'Into', 'Upon', 'When', 'After', 'Before', 'During', 'John', 'Jane', 'Doe', 'Example', 'New', 'Old', 'Current', 'Previous', 'Next', 'First', 'Last', 'All', 'Each', 'Every', 'Any', 'Given', 'Note', 'See', 'Also', 'More', 'Less', 'Here', 'There', 'Where', 'How', 'What', 'Which', 'Such', 'Like', 'Used', 'Uses', 'Using']);
 
   const capitalizedIdentifiers = outputText.match(/\b([A-Z][a-zA-Z]{2,})\b/g) || [];
   for (const identifier of capitalizedIdentifiers) {

package/src/utils/config.js

@@ -1,6 +1,32 @@
 'use strict';
 
 const { cosmiconfigSync } = require('cosmiconfig');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Session file stores auth state across CLI invocations.
+ * Lives in ~/.legacyver/session.json (user-level, not project-level).
+ */
+const SESSION_DIR = path.join(require('os').homedir(), '.legacyver');
+const SESSION_FILE = path.join(SESSION_DIR, 'session.json');
+
+function loadSession() {
+  try {
+    return JSON.parse(fs.readFileSync(SESSION_FILE, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function saveSession(data) {
+  fs.mkdirSync(SESSION_DIR, { recursive: true });
+  fs.writeFileSync(SESSION_FILE, JSON.stringify(data, null, 2), 'utf8');
+}
+
+function clearSession() {
+  try { fs.unlinkSync(SESSION_FILE); } catch { /* ignore */ }
+}
 
 const explorer = cosmiconfigSync('legacyver', {
   searchPlaces: [
@@ -33,7 +59,7 @@ function loadConfig(cliFlags = {}) {
   }
 
   const defaults = {
-    provider: 'openrouter',
+    provider: 'groq',
     model: undefined,
     format: 'markdown',
     out: './legacyver-docs',
@@ -61,4 +87,4 @@ function loadConfig(cliFlags = {}) {
   return { ...defaults, ...fileConfig, ...cleanCli };
 }
 
-module.exports = { loadConfig };
+module.exports = { loadConfig, loadSession, saveSession, clearSession };

package/temp_credentials/README.md

@@ -0,0 +1,61 @@
+# Team Infrastructure Usage Guide
+
+Welcome to your team infrastructure folder! Here’s how to use the files provided:
+
+## 1. `domain.txt`
+
+- This file contains your public application domain in the format:
+  
+  `https://<team-name>.hackathon.sev-2.com`
+
+- This domain will be configured in the Kubernetes ingress, so your deployed app will be accessible at this address.
+
+
+## 2. `db-credentials.txt`
+
+- This file contains your team's PostgreSQL database username, password, and database name.
+- You can find it in your team folder: `db-credentials.txt`.
+- Example content:
+
+  ```
+  rdms = "PostgreSQL"
+  host = "localhost"
+  port = 5432
+  username = "your_team_user"
+  password = "your_team_password"
+  database = "your_team_db"
+  ```
+
+- Use these credentials to connect your app or a database client to your team's schema.
+
+## 3. `kubeconfig.yaml`
+
+- This file allows you to connect to your team’s Kubernetes namespace/cluster.
+- Usage example:
+
+  ```sh
+  kubectl --kubeconfig=./kubeconfig.yaml -n <team-name> get pods
+  ```
+
+- You can use this file with `kubectl` or any Kubernetes-compatible tool.
+
+## Deployment Steps
+
+1. Dockerize your app
+2. Push your image to your container registry (e.g., Docker Hub).
+3. Deploy your application as usual (e.g., with `kubectl apply -f ...`).
+4. Ensure your app’s ingress resource uses the domain from `domain.txt`.
+5. Access your app at the public URL after deployment.
+
+---
+
+If you have questions, contact the hackathon team.
+
+---
+
+
+## Useful Links
+
+- [Kubernetes for Beginners (FreeCodeCamp)](https://www.freecodecamp.org/news/the-kubernetes-handbook/)
+- [kubectl Cheat Sheet (Kubernetes Official)](https://kubernetes.io/docs/reference/kubectl/cheatsheet/)
+- [Kubernetes Ingress Guide (Solo.io)](https://www.solo.io/topics/api-gateway/kubernetes-ingress)

package/temp_credentials/db-credentials.txt

@@ -0,0 +1,6 @@
+rdms = "PostgreSQL"
+host = "103.185.52.138"
+port = 1185
+username = "weci_holic"
+database = "weci_holic"
+password = "f==+HLH_bvzLN2fo82f3x239MZE3@bGF"

package/temp_credentials/domain.txt

@@ -0,0 +1 @@
+https://weci-holic.hackathon.sev-2.com

package/temp_credentials/kubeconfig.yaml

@@ -0,0 +1,18 @@
+apiVersion: v1
+kind: Config
+clusters:
+- name: local
+  cluster:
+    server: "https://103.185.52.45:6443"
+    certificate-authority-data: "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUJkekNDQVIyZ0F3SUJBZ0lCQURBS0JnZ3Foa2pPUFFRREFqQWpNU0V3SHdZRFZRUUREQmhyTTNNdGMyVnkKZG1WeUxXTmhRREUzTnpFek9UQTRNRFF3SGhjTk1qWXdNakU0TURVd01EQTBXaGNOTXpZd01qRTJNRFV3TURBMApXakFqTVNFd0h3WURWUVFEREJock0zTXRjMlZ5ZG1WeUxXTmhRREUzTnpFek9UQTRNRFF3V1RBVEJnY3Foa2pPClBRSUJCZ2dxaGtqT1BRTUJCd05DQUFTckpZTUNCdG9kU2lGZ2k1bkJ0YnNRaE4wcTRnSmRJQ2lzeGRwN2FGR00KcTVaWk5iQXpLbjNrd05hU2JmZ2sxL2xUQWFIWnFSUlI0czdqaEFIclhUMjZvMEl3UURBT0JnTlZIUThCQWY4RQpCQU1DQXFRd0R3WURWUjBUQVFIL0JBVXdBd0VCL3pBZEJnTlZIUTRFRmdRVXdHdVk4YVZ2QzVURDZnaUdFQlNTCmRrK2loU2t3Q2dZSUtvWkl6ajBFQXdJRFNBQXdSUUlnYld1Y1NkQUVsZ3orcmp2Z1hrU0hXTTRSQnlrQVo4VjQKWDBlTjhYZzdJMmNDSVFDZWRtR2pVMzVQaUtheVFnQS9NWHJMd2ZyL1pBeUU3eUJzWHo2bGN5VFZKZz09Ci0tLS0tRU5EIENFUlRJRklDQVRFLS0tLS0K"
+contexts:
+- name: weci-holic
+  context:
+    cluster: local
+    namespace: weci-holic
+    user: weci-holic-sa
+current-context: weci-holic
+users:
+- name: weci-holic-sa
+  user:
+    token: eyJhbGciOiJSUzI1NiIsImtpZCI6IlFteFl2cGk1RkF5TEFkdDJYSC05UnVmUGJhYXJCU0pBNjNEcUZxcEtsdFUifQ.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9uYW1lc3BhY2UiOiJ3ZWNpLWhvbGljIiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9zZWNyZXQubmFtZSI6IndlY2ktaG9saWMtc2EtdG9rZW4iLCJrdWJlcm5ldGVzLmlvL3NlcnZpY2VhY2NvdW50L3NlcnZpY2UtYWNjb3VudC5uYW1lIjoid2VjaS1ob2xpYy1zYSIsImt1YmVybmV0ZXMuaW8vc2VydmljZWFjY291bnQvc2VydmljZS1hY2NvdW50LnVpZCI6IjhlNjY0ZmQyLWNkNTYtNGEyNi1iNjE5LWRjYzg1Y2Y2ZWFjMiIsInN1YiI6InN5c3RlbTpzZXJ2aWNlYWNjb3VudDp3ZWNpLWhvbGljOndlY2ktaG9saWMtc2EifQ.jlBrE-ajb4CCj2244Kl-B-5jXikmNOh1kwbnMKttZFE8OJSi9xUEc1x6oQni1P83p5pkbqvreZpN8FtA-_YiMJpyMkjInWogfBc7TVvymJ0F0KQ-Ybxu2ibxkQvOOlNLuctCq4NbCm0oQaH3iBlvsFMpKuZJnogDwEbc6fompYrsxdXGh4F-zoh91mGiSsc7vyLfNJrKQvkivoOoaVwP2Y9xIZUnXMiTCExLUo1DthbRVN4PMPiCytJ6Tvg4LSMruu9-nW2be1hCgTV5IffB4hlhIgaWwCpBzygiWM4--Yg0tS-lejbquehDhVTWMkeOoZqzRKnMdU5iVyxBGB0pOA

package/temp_credentials/kubernetes-credentials.txt

@@ -0,0 +1,2 @@
+Kubernetes Namespace: weci-holic
+Kubernetes Config: kubeconfig.yaml

package/.agent/skills/openspec-apply-change/SKILL.md

@@ -1,156 +0,0 @@
----
-name: openspec-apply-change
-description: Implement tasks from an OpenSpec change. Use when the user wants to start implementing, continue implementation, or work through tasks.
-license: MIT
-compatibility: Requires openspec CLI.
-metadata:
-  author: openspec
-  version: "1.0"
-  generatedBy: "1.1.1"
----
-
-Implement tasks from an OpenSpec change.
-
-**Input**: Optionally specify a change name. If omitted, check if it can be inferred from conversation context. If vague or ambiguous you MUST prompt for available changes.
-
-**Steps**
-
-1. **Select the change**
-
-   If a name is provided, use it. Otherwise:
-   - Infer from conversation context if the user mentioned a change
-   - Auto-select if only one active change exists
-   - If ambiguous, run `openspec list --json` to get available changes and use the **AskUserQuestion tool** to let the user select
-
-   Always announce: "Using change: <name>" and how to override (e.g., `/opsx:apply <other>`).
-
-2. **Check status to understand the schema**
-   ```bash
-   openspec status --change "<name>" --json
-   ```
-   Parse the JSON to understand:
-   - `schemaName`: The workflow being used (e.g., "spec-driven")
-   - Which artifact contains the tasks (typically "tasks" for spec-driven, check status for others)
-
-3. **Get apply instructions**
-
-   ```bash
-   openspec instructions apply --change "<name>" --json
-   ```
-
-   This returns:
-   - Context file paths (varies by schema - could be proposal/specs/design/tasks or spec/tests/implementation/docs)
-   - Progress (total, complete, remaining)
-   - Task list with status
-   - Dynamic instruction based on current state
-
-   **Handle states:**
-   - If `state: "blocked"` (missing artifacts): show message, suggest using openspec-continue-change
-   - If `state: "all_done"`: congratulate, suggest archive
-   - Otherwise: proceed to implementation
-
-4. **Read context files**
-
-   Read the files listed in `contextFiles` from the apply instructions output.
-   The files depend on the schema being used:
-   - **spec-driven**: proposal, specs, design, tasks
-   - Other schemas: follow the contextFiles from CLI output
-
-5. **Show current progress**
-
-   Display:
-   - Schema being used
-   - Progress: "N/M tasks complete"
-   - Remaining tasks overview
-   - Dynamic instruction from CLI
-
-6. **Implement tasks (loop until done or blocked)**
-
-   For each pending task:
-   - Show which task is being worked on
-   - Make the code changes required
-   - Keep changes minimal and focused
-   - Mark task complete in the tasks file: `- [ ]` → `- [x]`
-   - Continue to next task
-
-   **Pause if:**
-   - Task is unclear → ask for clarification
-   - Implementation reveals a design issue → suggest updating artifacts
-   - Error or blocker encountered → report and wait for guidance
-   - User interrupts
-
-7. **On completion or pause, show status**
-
-   Display:
-   - Tasks completed this session
-   - Overall progress: "N/M tasks complete"
-   - If all done: suggest archive
-   - If paused: explain why and wait for guidance
-
-**Output During Implementation**
-
-```
-## Implementing: <change-name> (schema: <schema-name>)
-
-Working on task 3/7: <task description>
-[...implementation happening...]
-✓ Task complete
-
-Working on task 4/7: <task description>
-[...implementation happening...]
-✓ Task complete
-```
-
-**Output On Completion**
-
-```
-## Implementation Complete
-
-**Change:** <change-name>
-**Schema:** <schema-name>
-**Progress:** 7/7 tasks complete ✓
-
-### Completed This Session
-- [x] Task 1
-- [x] Task 2
-...
-
-All tasks complete! Ready to archive this change.
-```
-
-**Output On Pause (Issue Encountered)**
-
-```
-## Implementation Paused
-
-**Change:** <change-name>
-**Schema:** <schema-name>
-**Progress:** 4/7 tasks complete
-
-### Issue Encountered
-<description of the issue>
-
-**Options:**
-1. <option 1>
-2. <option 2>
-3. Other approach
-
-What would you like to do?
-```
-
-**Guardrails**
-- Keep going through tasks until done or blocked
-- Always read context files before starting (from the apply instructions output)
-- If task is ambiguous, pause and ask before implementing
-- If implementation reveals issues, pause and suggest artifact updates
-- Keep code changes minimal and scoped to each task
-- Update task checkbox immediately after completing each task
-- Pause on errors, blockers, or unclear requirements - don't guess
-- Use contextFiles from CLI output, don't assume specific file names
-
-**Fluid Workflow Integration**
-
-This skill supports the "actions on a change" model:
-
-- **Can be invoked anytime**: Before all artifacts are done (if tasks exist), after partial implementation, interleaved with other actions
-- **Allows artifact updates**: If implementation reveals design issues, suggest updating artifacts - not phase-locked, work fluidly