@slahon/lazykit 1.0.8 → 1.2.0

package/git.js

@@ -91,4 +91,13 @@ function detectStack() {
   return stack.length > 0 ? stack.join(' + ') : null;
 }
 
-module.exports = { getGitRemote, parseGitHubRepo, isGitRepo, isGhCliAvailable, isGhAuthenticated, detectStack };
+function hasBranchProtection({ owner, repo }) {
+  try {
+    execSync(`gh api repos/${owner}/${repo}/branches/main/protection`, { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = { getGitRemote, parseGitHubRepo, isGitRepo, isGhCliAvailable, isGhAuthenticated, detectStack, hasBranchProtection };

package/index.js

@@ -3,14 +3,36 @@
 'use strict';
 
 const { init } = require('./init');
+const { update } = require('./update');
+const { status } = require('./status');
+const { remove } = require('./remove');
 
-const [,, command] = process.argv;
+const [,, command, ...args] = process.argv;
+const dryRun = args.includes('--dry-run');
 
 switch (command) {
   case 'init':
   case undefined:
-    init().catch(err => {
-      console.error('\n❌ Setup failed:', err.message);
+    init({ dryRun }).catch(err => {
+      console.error('\n  Setup failed:', err.message);
+      process.exit(1);
+    });
+    break;
+  case 'update':
+    update({ dryRun }).catch(err => {
+      console.error('\n  Update failed:', err.message);
+      process.exit(1);
+    });
+    break;
+  case 'status':
+    status().catch(err => {
+      console.error('\n  Status check failed:', err.message);
+      process.exit(1);
+    });
+    break;
+  case 'remove':
+    remove().catch(err => {
+      console.error('\n  Remove failed:', err.message);
       process.exit(1);
     });
     break;
@@ -19,6 +41,12 @@ switch (command) {
 🦥  LazyKit — Drop an issue, get a PR.
 
 Usage:
-  npx lazykit init     Set up LazyKit in your current GitHub repo
+  npx @slahon/lazykit@latest init          Set up LazyKit in your current GitHub repo
+  npx @slahon/lazykit@latest update        Regenerate workflow and CLAUDE.md
+  npx @slahon/lazykit@latest status        Check if everything is wired up correctly
+  npx @slahon/lazykit@latest remove        Remove LazyKit from your repo
+
+Flags:
+  --dry-run    Preview what would happen without writing files (init, update)
 `);
 }

package/init.js

@@ -7,28 +7,30 @@ const chalk = require('chalk');
 const ora = require('ora');
 
 const { log } = require('./logger');
-const { ask, confirm, select } = require('./prompt');
-const { isGitRepo, getGitRemote, parseGitHubRepo, isGhCliAvailable, isGhAuthenticated, detectStack } = require('./git');
+const { ask, confirm } = require('./prompt');
+const { isGitRepo, getGitRemote, parseGitHubRepo, isGhCliAvailable, isGhAuthenticated, detectStack, hasBranchProtection } = require('./git');
 const { generateWorkflow } = require('./workflow');
 const { generateClaudeMd } = require('./claude-md');
+const { generateIssueTemplate } = require('./issue-template');
+
+async function init({ dryRun = false } = {}) {
+  if (dryRun) console.log(chalk.yellow('\n  [dry-run] Preview mode — no files will be written or API calls made.\n'));
 
-async function init() {
   console.log(chalk.bold.white('\n🦥  LazyKit — Drop an issue, get a PR.\n'));
   console.log(chalk.gray('  This will set up AI-powered issue-to-PR automation in your repo.\n'));
 
-  // ─── Step 1: Verify git repo ─────────────────────────────────────────────
+  // ─── Step 1: Verify git repo ──────────────────────────────────────────────
   if (!isGitRepo()) {
     log.error('Not inside a git repository.');
     console.log(chalk.gray('\n  LazyKit needs a git repo with a GitHub remote. To set one up:\n'));
     console.log(chalk.cyan('    git init'));
     console.log(chalk.cyan('    git remote add origin https://github.com/<you>/<repo>'));
-    console.log(chalk.gray('\n  Then re-run: ') + chalk.cyan('npx @slahon/lazykit init\n'));
+    console.log(chalk.gray('\n  Then re-run: ') + chalk.cyan('npx @slahon/lazykit@latest init\n'));
     process.exit(1);
   }
 
   const remote = getGitRemote();
   const repoInfo = parseGitHubRepo(remote);
-
   const stack = detectStack();
 
   if (repoInfo) {
@@ -39,11 +41,11 @@ async function init() {
     console.log(chalk.gray('\n  LazyKit requires a GitHub repository with a remote set up.\n'));
     console.log(chalk.gray('  To fix this, connect your repo to GitHub first:\n'));
     console.log(chalk.cyan('    git remote add origin https://github.com/<you>/<repo>'));
-    console.log(chalk.gray('\n  Then re-run: ') + chalk.cyan('npx @slahon/lazykit init\n'));
+    console.log(chalk.gray('\n  Then re-run: ') + chalk.cyan('npx @slahon/lazykit@latest init\n'));
     process.exit(1);
   }
 
-  // ─── Step 2: Check gh CLI and auth ──────────────────────────────────────
+  // ─── Step 2: Check gh CLI and auth ───────────────────────────────────────
   const ghAvailable = isGhCliAvailable();
   let ghReady = false;
 
@@ -68,49 +70,66 @@ async function init() {
 
   log.blank();
 
-  // ─── Step 3: Ask questions ───────────────────────────────────────────────
+  // ─── Step 3: Ask questions ────────────────────────────────────────────────
   log.title('Configure LazyKit');
   log.blank();
 
   const label = await ask('Label name to trigger Claude', 'lazykit');
-
+  const autoTrigger = await confirm('Trigger Claude on every new issue automatically? (no = only when you apply the label)', true);
   const wantClaudeMd = await confirm('Generate CLAUDE.md project guide?', true);
 
   log.blank();
 
-  // ─── Step 4: Create workflow file ────────────────────────────────────────
-  const spinner = ora({ text: 'Creating workflow file...', color: 'cyan' }).start();
-
+  // ─── Step 4: Create workflow file ─────────────────────────────────────────
   const workflowDir = path.join(process.cwd(), '.github', 'workflows');
-  fs.mkdirSync(workflowDir, { recursive: true });
-
   const workflowPath = path.join(workflowDir, 'lazykit.yml');
-  const workflowContent = generateWorkflow({ label });
-  fs.writeFileSync(workflowPath, workflowContent);
 
-  spinner.succeed(chalk.green('Created .github/workflows/lazykit.yml'));
+  if (dryRun) {
+    log.info('[dry-run] Would create: .github/workflows/lazykit.yml');
+  } else {
+    const spinner = ora({ text: 'Creating workflow file...', color: 'cyan' }).start();
+    fs.mkdirSync(workflowDir, { recursive: true });
+    fs.writeFileSync(workflowPath, generateWorkflow({ label, autoTrigger }));
+    spinner.succeed(chalk.green('Created .github/workflows/lazykit.yml'));
+  }
+
+  // ─── Step 5: Create issue template ───────────────────────────────────────
+  const templateDir = path.join(process.cwd(), '.github', 'ISSUE_TEMPLATE');
+  const templatePath = path.join(templateDir, 'lazykit.md');
 
-  // ─── Step 5: Create CLAUDE.md ────────────────────────────────────────────
+  if (dryRun) {
+    log.info('[dry-run] Would create: .github/ISSUE_TEMPLATE/lazykit.md');
+  } else {
+    const spinner = ora({ text: 'Creating issue template...', color: 'cyan' }).start();
+    fs.mkdirSync(templateDir, { recursive: true });
+    fs.writeFileSync(templatePath, generateIssueTemplate({ label }));
+    spinner.succeed(chalk.green('Created .github/ISSUE_TEMPLATE/lazykit.md'));
+  }
+
+  // ─── Step 6: Create CLAUDE.md ─────────────────────────────────────────────
   if (wantClaudeMd) {
     const claudeMdPath = path.join(process.cwd(), 'CLAUDE.md');
-    const claudeMdContent = generateClaudeMd({ stack });
 
-    if (fs.existsSync(claudeMdPath)) {
+    if (dryRun) {
+      log.info('[dry-run] Would create: CLAUDE.md');
+    } else if (fs.existsSync(claudeMdPath)) {
       const overwrite = await confirm('CLAUDE.md already exists. Overwrite?', false);
       if (overwrite) {
-        fs.writeFileSync(claudeMdPath, claudeMdContent);
+        fs.writeFileSync(claudeMdPath, generateClaudeMd({ stack }));
         log.success('Updated CLAUDE.md');
       } else {
         log.warn('Skipped CLAUDE.md — keeping existing file.');
       }
     } else {
-      fs.writeFileSync(claudeMdPath, claudeMdContent);
+      fs.writeFileSync(claudeMdPath, generateClaudeMd({ stack }));
       log.success('Created CLAUDE.md');
     }
   }
 
-  // ─── Step 6: Create GitHub label ─────────────────────────────────────────
-  if (ghReady) {
+  // ─── Step 7: Create GitHub label ──────────────────────────────────────────
+  if (dryRun) {
+    log.info(`[dry-run] Would create GitHub label: '${label}'`);
+  } else if (ghReady) {
     const labelSpinner = ora({ text: `Creating '${label}' label on GitHub...`, color: 'cyan' }).start();
     try {
       execSync(
@@ -123,15 +142,17 @@ async function init() {
       if (msg.includes('already exists')) {
         labelSpinner.succeed(chalk.green(`Label '${label}' already exists — skipping`));
       } else {
-        labelSpinner.warn(chalk.yellow(`Could not create label automatically — you'll need to create it manually`));
+        labelSpinner.warn(chalk.yellow(`Could not create label — create it manually at https://github.com/${repoInfo.owner}/${repoInfo.repo}/labels`));
       }
     }
   } else {
     log.warn(`Create the '${label}' label manually at: ${chalk.cyan(`https://github.com/${repoInfo.owner}/${repoInfo.repo}/labels`)}`);
   }
 
-  // ─── Step 7: Enable Actions to create PRs ────────────────────────────────
-  if (ghReady) {
+  // ─── Step 8: Enable Actions PR creation ───────────────────────────────────
+  if (dryRun) {
+    log.info('[dry-run] Would enable Actions PR creation permission');
+  } else if (ghReady) {
     const prSpinner = ora({ text: 'Enabling Actions PR creation permission...', color: 'cyan' }).start();
     try {
       execSync(
@@ -152,69 +173,109 @@ async function init() {
     }
   }
 
-  // ─── Step 8: Generate and set Claude token ───────────────────────────────
-  console.log('\n' + chalk.bold.green('  ✨ Almost there — setting up your Claude token...\n'));
-
-  let tokenSet = false;
-
-  try {
-    log.info('Running claude setup-token (a browser window may open to authenticate)...');
-    console.log();
-
-    const result = spawnSync('claude', ['setup-token'], {
-      stdio: ['inherit', 'pipe', 'pipe'],
-      encoding: 'utf8',
-    });
-
-    if (result.stderr) process.stderr.write(result.stderr);
+  // ─── Step 9: Branch protection warning ────────────────────────────────────
+  if (!dryRun && ghReady && hasBranchProtection(repoInfo)) {
+    log.warn('Branch protection is enabled on main.');
+    console.log(chalk.gray("  Claude's PRs will be opened but cannot be auto-merged — they require manual review.\n"));
+  }
 
-    const output = (result.stdout || '') + (result.stderr || '');
-    const tokenMatch = output.match(/sk-ant-oat[^\s]+/);
+  // ─── Step 10: Generate and set Claude token ────────────────────────────────
+  if (dryRun) {
+    log.info('[dry-run] Would run claude setup-token and set CLAUDE_CODE_OAUTH_TOKEN secret');
+  } else {
+    console.log('\n' + chalk.bold.green('  ✨ Almost there — setting up your Claude token...\n'));
 
-    if (tokenMatch && ghReady) {
-      const token = tokenMatch[0];
-      const secretSpinner = ora({ text: 'Adding CLAUDE_CODE_OAUTH_TOKEN to GitHub secrets...', color: 'cyan' }).start();
-      execSync(
-        `gh secret set CLAUDE_CODE_OAUTH_TOKEN --body "${token}" --repo ${repoInfo.owner}/${repoInfo.repo}`,
-        { stdio: 'pipe' }
-      );
-      secretSpinner.succeed(chalk.green('CLAUDE_CODE_OAUTH_TOKEN added to GitHub secrets'));
-      tokenSet = true;
-    } else if (tokenMatch && !ghReady) {
-      log.warn('Token generated but gh CLI not found — add it manually:');
-      console.log(chalk.gray('       Name:  ') + chalk.cyan('CLAUDE_CODE_OAUTH_TOKEN'));
-      console.log(chalk.gray('       Value: ') + chalk.cyan(tokenMatch[0]));
-      console.log(chalk.cyan(`       https://github.com/${repoInfo.owner}/${repoInfo.repo}/settings/secrets/actions`));
-    } else {
-      throw new Error('Token not found in output');
-    }
-  } catch (err) {
-    const isNotFound = err.status === 'ENOENT' || (err.message || '').includes('ENOENT');
-    if (isNotFound) {
-      log.warn('Claude Code CLI not found — install it first:');
-      console.log(chalk.cyan('\n    npm install -g @anthropic-ai/claude-code'));
-    } else {
-      log.warn('Could not set token automatically.');
+    try {
+      log.info('Running claude setup-token (a browser window may open to authenticate)...');
+      console.log();
+
+      const result = spawnSync('claude', ['setup-token'], {
+        stdio: ['inherit', 'pipe', 'pipe'],
+        encoding: 'utf8',
+      });
+
+      if (result.stderr) process.stderr.write(result.stderr);
+
+      const output = (result.stdout || '') + (result.stderr || '');
+      const tokenMatch = output.match(/sk-ant-oat[^\s]+/);
+
+      if (tokenMatch && ghReady) {
+        const secretSpinner = ora({ text: 'Adding CLAUDE_CODE_OAUTH_TOKEN to GitHub secrets...', color: 'cyan' }).start();
+        execSync(
+          `gh secret set CLAUDE_CODE_OAUTH_TOKEN --body "${tokenMatch[0]}" --repo ${repoInfo.owner}/${repoInfo.repo}`,
+          { stdio: 'pipe' }
+        );
+        secretSpinner.succeed(chalk.green('CLAUDE_CODE_OAUTH_TOKEN added to GitHub secrets'));
+      } else if (tokenMatch && !ghReady) {
+        log.warn('Token generated but gh CLI not available — add it manually:');
+        console.log(chalk.gray('       Name:  ') + chalk.cyan('CLAUDE_CODE_OAUTH_TOKEN'));
+        console.log(chalk.gray('       Value: ') + chalk.cyan(tokenMatch[0]));
+        console.log(chalk.cyan(`       https://github.com/${repoInfo.owner}/${repoInfo.repo}/settings/secrets/actions`));
+      } else {
+        throw new Error('Token not found in output');
+      }
+    } catch (err) {
+      const isNotFound = (err.message || '').includes('ENOENT');
+      if (isNotFound) {
+        log.warn('Claude Code CLI not found — install it first:');
+        console.log(chalk.cyan('\n    npm install -g @anthropic-ai/claude-code'));
+      } else {
+        log.warn('Could not set token automatically.');
+      }
+      console.log(chalk.gray('\n  Add it manually:'));
+      console.log(chalk.gray('    1. Run:        ') + chalk.cyan('claude setup-token'));
+      console.log(chalk.gray('    2. Go to:      ') + chalk.cyan(`https://github.com/${repoInfo.owner}/${repoInfo.repo}/settings/secrets/actions`));
+      console.log(chalk.gray('    3. Add secret: ') + chalk.cyan('CLAUDE_CODE_OAUTH_TOKEN') + chalk.gray(' = the token you copied\n'));
     }
-    console.log(chalk.gray('\n  Add it manually:'));
-    console.log(chalk.gray('    1. Run:       ') + chalk.cyan('claude setup-token'));
-    console.log(chalk.gray('    2. Go to:     ') + chalk.cyan(`https://github.com/${repoInfo.owner}/${repoInfo.repo}/settings/secrets/actions`));
-    console.log(chalk.gray('    3. Add secret:') + chalk.cyan(' CLAUDE_CODE_OAUTH_TOKEN') + chalk.gray(' = the token you copied\n'));
   }
 
   log.divider();
 
-  console.log(chalk.bold('\n  Then commit and push the new files:\n'));
-  console.log(chalk.cyan('    git add .github/workflows/lazykit.yml' + (wantClaudeMd ? ' CLAUDE.md' : '')));
-  console.log(chalk.cyan('    git commit -m "Add LazyKit automation"'));
-  console.log(chalk.cyan('    git push'));
+  // ─── Step 11: Commit and push ──────────────────────────────────────────────
+  if (dryRun) {
+    log.info('[dry-run] Would commit and push generated files');
+    log.blank();
+  } else {
+    const autoPush = await confirm('Commit and push the generated files now?', true);
+
+    if (autoPush) {
+      const pushSpinner = ora({ text: 'Committing and pushing...', color: 'cyan' }).start();
+      try {
+        const files = [
+          '.github/workflows/lazykit.yml',
+          '.github/ISSUE_TEMPLATE/lazykit.md',
+          ...(wantClaudeMd ? ['CLAUDE.md'] : []),
+        ].join(' ');
+        execSync(`git add ${files}`, { stdio: 'pipe' });
+        execSync(`git commit -m "Add LazyKit automation"`, { stdio: 'pipe' });
+        execSync(`git push`, { stdio: 'pipe' });
+        pushSpinner.succeed(chalk.green('Committed and pushed — workflow is live'));
+      } catch {
+        pushSpinner.fail(chalk.red('Push failed.'));
+        console.log(chalk.gray('\n  Push it manually:\n'));
+        console.log(chalk.cyan(`    git add .github/workflows/lazykit.yml .github/ISSUE_TEMPLATE/lazykit.md${wantClaudeMd ? ' CLAUDE.md' : ''}`));
+        console.log(chalk.cyan('    git commit -m "Add LazyKit automation"'));
+        console.log(chalk.cyan('    git push\n'));
+      }
+    } else {
+      console.log(chalk.bold('\n  Push the files yourself when ready:\n'));
+      console.log(chalk.cyan(`    git add .github/workflows/lazykit.yml .github/ISSUE_TEMPLATE/lazykit.md${wantClaudeMd ? ' CLAUDE.md' : ''}`));
+      console.log(chalk.cyan('    git commit -m "Add LazyKit automation"'));
+      console.log(chalk.cyan('    git push'));
+    }
+  }
 
   log.divider();
 
   console.log(chalk.bold('\n  Done! Here is how to use it:\n'));
-  console.log(`  ${chalk.gray('1.')} Open a GitHub issue describing what you want`);
-  console.log(`  ${chalk.gray('2.')} Apply the ${chalk.bold.magenta(label)} label`);
-  console.log(`  ${chalk.gray('3.')} Watch Claude open a PR with the changes\n`);
+  console.log(`  ${chalk.gray('1.')} Open a GitHub issue using the ${chalk.bold.magenta('LazyKit Task')} template`);
+  if (autoTrigger) {
+    console.log(`  ${chalk.gray('2.')} Claude starts working on it automatically`);
+  } else {
+    console.log(`  ${chalk.gray('2.')} Apply the ${chalk.bold.magenta(label)} label to trigger Claude`);
+  }
+  console.log(`  ${chalk.gray('3.')} Review and merge the pull request`);
+  console.log(`\n  ${chalk.gray('Tip:')} Mention ${chalk.bold.cyan('@claude')} in any issue comment to give follow-up instructions.\n`);
 
   console.log(chalk.bold.white('  🦥  LazyKit is ready. Go be lazy.\n'));
 }

package/issue-template.js

@@ -0,0 +1,24 @@
+'use strict';
+
+function generateIssueTemplate({ label }) {
+  return `---
+name: LazyKit Task
+about: Describe a task for Claude to implement
+labels: ${label}
+---
+
+## What to build
+
+<!-- Describe clearly and specifically what you want Claude to implement. Keep it small and focused. -->
+
+## Acceptance criteria
+
+<!-- Optional: what does "done" look like? -->
+
+## Notes
+
+<!-- Files to touch, things to avoid, constraints, or extra context for Claude. -->
+`;
+}
+
+module.exports = { generateIssueTemplate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slahon/lazykit",
-  "version": "1.0.8",
+  "version": "1.2.0",
   "description": "Drop an issue, get a PR. AI-powered issue-to-PR automation using Claude.",
   "bin": {
     "lazykit": "./index.js"

package/remove.js

@@ -0,0 +1,104 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+const ora = require('ora');
+
+const { log } = require('./logger');
+const { confirm } = require('./prompt');
+const { isGitRepo, getGitRemote, parseGitHubRepo, isGhCliAvailable, isGhAuthenticated } = require('./git');
+
+async function remove() {
+  console.log(chalk.bold.white('\n🦥  LazyKit Remove\n'));
+
+  if (!isGitRepo()) {
+    log.error('Not inside a git repository.');
+    process.exit(1);
+  }
+
+  const repoInfo = parseGitHubRepo(getGitRemote());
+  if (!repoInfo) {
+    log.error('No GitHub remote detected.');
+    process.exit(1);
+  }
+
+  const confirmed = await confirm('This will remove LazyKit from your repo. Continue?', false);
+  if (!confirmed) {
+    console.log(chalk.gray('\n  Aborted.\n'));
+    process.exit(0);
+  }
+
+  const ghReady = isGhCliAvailable() && isGhAuthenticated();
+  const deleted = [];
+
+  // Read label name before deleting workflow
+  let labelName = 'lazykit';
+  const workflowPath = path.join(process.cwd(), '.github', 'workflows', 'lazykit.yml');
+  if (fs.existsSync(workflowPath)) {
+    const wf = fs.readFileSync(workflowPath, 'utf8');
+    const m = wf.match(/label_trigger:\s*(\S+)/);
+    if (m) labelName = m[1];
+    fs.unlinkSync(workflowPath);
+    deleted.push('.github/workflows/lazykit.yml');
+    log.success('Removed .github/workflows/lazykit.yml');
+  }
+
+  const templatePath = path.join(process.cwd(), '.github', 'ISSUE_TEMPLATE', 'lazykit.md');
+  if (fs.existsSync(templatePath)) {
+    fs.unlinkSync(templatePath);
+    deleted.push('.github/ISSUE_TEMPLATE/lazykit.md');
+    log.success('Removed .github/ISSUE_TEMPLATE/lazykit.md');
+  }
+
+  const claudeMdPath = path.join(process.cwd(), 'CLAUDE.md');
+  if (fs.existsSync(claudeMdPath)) {
+    const removeClaude = await confirm('Remove CLAUDE.md too?', false);
+    if (removeClaude) {
+      fs.unlinkSync(claudeMdPath);
+      deleted.push('CLAUDE.md');
+      log.success('Removed CLAUDE.md');
+    }
+  }
+
+  if (ghReady) {
+    const labelSpinner = ora({ text: `Deleting '${labelName}' label from GitHub...`, color: 'cyan' }).start();
+    try {
+      execSync(`gh label delete "${labelName}" --repo ${repoInfo.owner}/${repoInfo.repo} --yes`, { stdio: 'pipe' });
+      labelSpinner.succeed(chalk.green(`Deleted '${labelName}' label from GitHub`));
+    } catch {
+      labelSpinner.warn(`Could not delete label — remove manually at ${chalk.cyan(`https://github.com/${repoInfo.owner}/${repoInfo.repo}/labels`)}`);
+    }
+
+    const secretSpinner = ora({ text: 'Removing CLAUDE_CODE_OAUTH_TOKEN secret...', color: 'cyan' }).start();
+    try {
+      execSync(`gh secret delete CLAUDE_CODE_OAUTH_TOKEN --repo ${repoInfo.owner}/${repoInfo.repo}`, { stdio: 'pipe' });
+      secretSpinner.succeed(chalk.green('Removed CLAUDE_CODE_OAUTH_TOKEN secret'));
+    } catch {
+      secretSpinner.warn(`Could not remove secret — delete manually in repo Settings → Secrets`);
+    }
+  } else {
+    log.warn(`Remove the '${labelName}' label manually: ${chalk.cyan(`https://github.com/${repoInfo.owner}/${repoInfo.repo}/labels`)}`);
+    log.warn(`Remove the CLAUDE_CODE_OAUTH_TOKEN secret manually: ${chalk.cyan(`https://github.com/${repoInfo.owner}/${repoInfo.repo}/settings/secrets/actions`)}`);
+  }
+
+  if (deleted.length > 0) {
+    const autoPush = await confirm('Commit and push the removals?', true);
+    if (autoPush) {
+      const spinner = ora({ text: 'Committing and pushing...', color: 'cyan' }).start();
+      try {
+        execSync(`git add ${deleted.map(f => `"${f}"`).join(' ')}`, { stdio: 'pipe' });
+        execSync(`git commit -m "Remove LazyKit automation"`, { stdio: 'pipe' });
+        execSync(`git push`, { stdio: 'pipe' });
+        spinner.succeed(chalk.green('Committed and pushed'));
+      } catch {
+        spinner.fail('Push failed — commit and push manually');
+      }
+    }
+  }
+
+  console.log(chalk.bold.white('\n  LazyKit has been removed.\n'));
+}
+
+module.exports = { remove };

package/status.js

@@ -0,0 +1,113 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+
+const { log } = require('./logger');
+const { isGitRepo, getGitRemote, parseGitHubRepo, isGhCliAvailable, isGhAuthenticated } = require('./git');
+
+async function status() {
+  console.log(chalk.bold.white('\n🦥  LazyKit Status\n'));
+
+  if (!isGitRepo()) {
+    log.error('Not inside a git repository.');
+    return;
+  }
+
+  const repoInfo = parseGitHubRepo(getGitRemote());
+  if (!repoInfo) {
+    log.error('No GitHub remote detected.');
+    return;
+  }
+
+  log.info(`Repo: ${chalk.cyan(`${repoInfo.owner}/${repoInfo.repo}`)}`);
+  log.blank();
+
+  // Local files
+  const workflowPath = path.join(process.cwd(), '.github', 'workflows', 'lazykit.yml');
+  const claudeMdPath = path.join(process.cwd(), 'CLAUDE.md');
+  const templatePath = path.join(process.cwd(), '.github', 'ISSUE_TEMPLATE', 'lazykit.md');
+
+  fs.existsSync(workflowPath)
+    ? log.success('Workflow file found')
+    : log.error('Workflow file missing — run npx @slahon/lazykit@latest init');
+
+  fs.existsSync(templatePath)
+    ? log.success('Issue template found')
+    : log.warn('Issue template missing — run npx @slahon/lazykit@latest init');
+
+  fs.existsSync(claudeMdPath)
+    ? log.success('CLAUDE.md found')
+    : log.warn('CLAUDE.md not found — Claude has no project context');
+
+  // Remote checks require gh
+  const ghReady = isGhCliAvailable() && isGhAuthenticated();
+  if (!ghReady) {
+    log.blank();
+    log.warn('gh CLI not available or not authenticated — skipping remote checks');
+    log.warn('Run: ' + chalk.cyan('gh auth login'));
+    console.log();
+    return;
+  }
+
+  log.blank();
+
+  // Secret
+  try {
+    const secrets = execSync(`gh secret list --repo ${repoInfo.owner}/${repoInfo.repo}`, { stdio: 'pipe' }).toString();
+    const match = secrets.match(/CLAUDE_CODE_OAUTH_TOKEN\s+(\S+)/);
+    if (match) {
+      const updated = new Date(match[1]);
+      const monthsOld = (Date.now() - updated.getTime()) / (1000 * 60 * 60 * 24 * 30);
+      log.success(`CLAUDE_CODE_OAUTH_TOKEN secret exists ${chalk.gray(`(updated ${match[1]})`)}`);
+      if (monthsOld > 6) log.warn('Token is over 6 months old — consider refreshing it with npx @slahon/lazykit@latest init');
+    } else {
+      log.error('CLAUDE_CODE_OAUTH_TOKEN secret not found — run npx @slahon/lazykit@latest init');
+    }
+  } catch {
+    log.warn('Could not check secrets — insufficient permissions');
+  }
+
+  // Label
+  try {
+    let labelName = 'lazykit';
+    if (fs.existsSync(workflowPath)) {
+      const wf = fs.readFileSync(workflowPath, 'utf8');
+      const m = wf.match(/label_trigger:\s*(\S+)/);
+      if (m) labelName = m[1];
+    }
+    const labels = execSync(`gh label list --repo ${repoInfo.owner}/${repoInfo.repo}`, { stdio: 'pipe' }).toString();
+    labels.includes(labelName)
+      ? log.success(`Label '${labelName}' exists on GitHub`)
+      : log.error(`Label '${labelName}' not found — run npx @slahon/lazykit@latest init`);
+  } catch {
+    log.warn('Could not check labels');
+  }
+
+  // PR creation permission
+  try {
+    const perms = JSON.parse(execSync(
+      `gh api repos/${repoInfo.owner}/${repoInfo.repo}/actions/permissions/workflow`,
+      { stdio: 'pipe' }
+    ).toString());
+    perms.can_approve_pull_request_reviews
+      ? log.success('Actions can create and approve pull requests')
+      : log.warn(`PR creation not enabled — ${chalk.cyan(`https://github.com/${repoInfo.owner}/${repoInfo.repo}/settings/actions`)}`);
+  } catch {
+    log.warn('Could not check Actions permissions');
+  }
+
+  // Branch protection
+  try {
+    execSync(`gh api repos/${repoInfo.owner}/${repoInfo.repo}/branches/main/protection`, { stdio: 'pipe' });
+    log.warn("Branch protection is on — Claude's PRs require manual review before merge");
+  } catch {
+    log.success("No branch protection on main — Claude's PRs can be merged directly");
+  }
+
+  console.log();
+}
+
+module.exports = { status };

package/update.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+const ora = require('ora');
+
+const { log } = require('./logger');
+const { confirm } = require('./prompt');
+const { isGitRepo, getGitRemote, parseGitHubRepo, detectStack } = require('./git');
+const { generateWorkflow } = require('./workflow');
+const { generateClaudeMd } = require('./claude-md');
+
+async function update({ dryRun = false } = {}) {
+  if (dryRun) console.log(chalk.yellow('\n  [dry-run] Preview mode — no files will be written.\n'));
+  console.log(chalk.bold.white('\n🦥  LazyKit Update\n'));
+
+  if (!isGitRepo()) {
+    log.error('Not inside a git repository.');
+    process.exit(1);
+  }
+
+  const repoInfo = parseGitHubRepo(getGitRemote());
+  if (!repoInfo) {
+    log.error('No GitHub remote detected.');
+    process.exit(1);
+  }
+
+  const workflowPath = path.join(process.cwd(), '.github', 'workflows', 'lazykit.yml');
+  const claudeMdPath = path.join(process.cwd(), 'CLAUDE.md');
+
+  // Read existing config from workflow file
+  let label = 'lazykit';
+  let autoTrigger = true;
+  if (fs.existsSync(workflowPath)) {
+    const wf = fs.readFileSync(workflowPath, 'utf8');
+    const m = wf.match(/label_trigger:\s*(\S+)/);
+    if (m) label = m[1];
+    autoTrigger = wf.includes("github.event.action == 'opened'");
+  }
+
+  const stack = detectStack();
+  const filesToPush = [];
+
+  // Regenerate workflow
+  if (dryRun) {
+    log.info('[dry-run] Would update: .github/workflows/lazykit.yml');
+  } else {
+    const spinner = ora({ text: 'Updating workflow file...', color: 'cyan' }).start();
+    fs.mkdirSync(path.dirname(workflowPath), { recursive: true });
+    fs.writeFileSync(workflowPath, generateWorkflow({ label, autoTrigger }));
+    spinner.succeed(chalk.green('Updated .github/workflows/lazykit.yml'));
+    filesToPush.push('.github/workflows/lazykit.yml');
+  }
+
+  // Regenerate CLAUDE.md if it exists
+  if (fs.existsSync(claudeMdPath)) {
+    const regen = await confirm('Regenerate CLAUDE.md?', true);
+    if (regen) {
+      if (dryRun) {
+        log.info('[dry-run] Would update: CLAUDE.md');
+      } else {
+        fs.writeFileSync(claudeMdPath, generateClaudeMd({ stack }));
+        log.success('Updated CLAUDE.md');
+        filesToPush.push('CLAUDE.md');
+      }
+    }
+  }
+
+  if (!dryRun && filesToPush.length > 0) {
+    const autoPush = await confirm('Commit and push?', true);
+    if (autoPush) {
+      const spinner = ora({ text: 'Committing and pushing...', color: 'cyan' }).start();
+      try {
+        execSync(`git add ${filesToPush.join(' ')}`, { stdio: 'pipe' });
+        execSync(`git commit -m "Update LazyKit configuration"`, { stdio: 'pipe' });
+        execSync(`git push`, { stdio: 'pipe' });
+        spinner.succeed(chalk.green('Committed and pushed'));
+      } catch {
+        spinner.fail('Push failed — commit and push manually');
+      }
+    }
+  }
+
+  console.log();
+}
+
+module.exports = { update };

package/workflow.js

@@ -1,16 +1,30 @@
 'use strict';
 
-function generateWorkflow({ label }) {
+function generateWorkflow({ label, autoTrigger }) {
   const checkList = `            1. Review your changes and make sure no existing functionality is broken.
             2. If you encounter errors you cannot fix, post a comment on the issue explaining what went wrong instead of committing broken code.`;
 
-  return `name: LazyKit
-
-on:
+  const trigger = autoTrigger
+    ? `on:
+  issues:
+    types: [opened]
+  issue_comment:
+    types: [created]`
+    : `on:
   issues:
     types: [opened, labeled]
   issue_comment:
-    types: [created]
+    types: [created]`;
+
+  const condition = autoTrigger
+    ? `github.event.action == 'opened' ||
+      contains(github.event.comment.body, '@claude')`
+    : `contains(github.event.issue.labels.*.name, '${label}') ||
+      contains(github.event.comment.body, '@claude')`;
+
+  return `name: LazyKit
+
+${trigger}
 
 concurrency:
   group: lazykit-\${{ github.event.issue.number }}
@@ -19,8 +33,7 @@ concurrency:
 jobs:
   lazykit:
     if: >
-      contains(github.event.issue.labels.*.name, '${label}') ||
-      contains(github.event.comment.body, '@claude')
+      ${condition}
     runs-on: ubuntu-latest
     timeout-minutes: 30
     permissions: