@tsuzuku/arise 0.2.0

package/lib/layout.js

@@ -0,0 +1,88 @@
+const herdr = require('./herdr');
+
+/**
+ * Default standard 4-pane quadrant layout recipe
+ */
+const DEFAULT_QUADRANT_LAYOUT = [
+  { id: 'vim', title: 'vim', cmd: 'vim .', position: 'root' },
+  { id: 'server', title: 'server', cmd: null, split: 'right', from: 'vim' },
+  { id: 'shell', title: 'shell', cmd: null, split: 'down', from: 'vim' },
+  { id: 'agy', title: 'agy', cmd: 'agy', split: 'down', from: 'server', focus: true, isAgent: true },
+];
+
+/**
+ * Render a declarative layout onto a Herdr workspace
+ * 
+ * @param {Object} options
+ * @param {Array} options.layout Array of pane definitions
+ * @param {string} options.rootPaneId ID of the root pane created with workspace
+ * @param {string} options.cwd Working directory for panes
+ * @param {string} options.focusTarget Name or ID of pane to focus (e.g. 'agent', 'agy', 'claude', 'vim', 'logs', 'shell')
+ */
+function renderLayout({ layout = DEFAULT_QUADRANT_LAYOUT, rootPaneId, cwd, focusTarget = 'agy' }) {
+  const paneMap = new Map(); // id -> paneId
+  let targetFocusPaneId = null;
+
+  // 1. First pass: identify which pane is targeted for focus
+  const normalizedFocus = (focusTarget || 'agy').toLowerCase().trim();
+
+  // Helper to check if a pane matches focus target
+  function isFocusMatch(paneDef) {
+    if (!normalizedFocus) return false;
+    const idMatch = paneDef.id && paneDef.id.toLowerCase() === normalizedFocus;
+    const titleMatch = paneDef.title && paneDef.title.toLowerCase() === normalizedFocus;
+    const cmdMatch = paneDef.cmd && paneDef.cmd.toLowerCase().split(/\s+/)[0] === normalizedFocus;
+    const agentAlias = (normalizedFocus === 'agent' || normalizedFocus === 'agy' || normalizedFocus === 'ai') &&
+      (paneDef.id === 'agy' || paneDef.id === 'agent' || paneDef.isAgent);
+    return Boolean(idMatch || titleMatch || cmdMatch || agentAlias);
+  }
+
+  // 2. Iterate through pane definitions
+  for (const paneDef of layout) {
+    let currentPaneId;
+
+    if (paneDef.position === 'root' || !paneDef.from) {
+      currentPaneId = rootPaneId;
+    } else {
+      const parentPaneId = paneMap.get(paneDef.from);
+      if (!parentPaneId) {
+        console.warn(`Layout warning: parent pane "${paneDef.from}" not found for "${paneDef.id}".`);
+        continue;
+      }
+
+      const shouldFocus = isFocusMatch(paneDef);
+      currentPaneId = herdr.splitPane({
+        paneId: parentPaneId,
+        direction: paneDef.split || 'right',
+        cwd,
+        focus: shouldFocus,
+      });
+    }
+
+    if (currentPaneId) {
+      paneMap.set(paneDef.id, currentPaneId);
+
+      if (paneDef.title) {
+        herdr.renamePane(currentPaneId, paneDef.title);
+      }
+
+      if (paneDef.cmd) {
+        herdr.runInPane(currentPaneId, paneDef.cmd);
+      }
+
+      if (isFocusMatch(paneDef)) {
+        targetFocusPaneId = currentPaneId;
+      }
+    }
+  }
+
+  return {
+    paneMap,
+    targetFocusPaneId,
+  };
+}
+
+module.exports = {
+  renderLayout,
+  DEFAULT_QUADRANT_LAYOUT,
+};

package/lib/lifecycle/create.js

@@ -0,0 +1,131 @@
+const fs = require('fs');
+const path = require('path');
+const git = require('../git');
+const herdr = require('../herdr');
+const layout = require('../layout');
+const { createContext } = require('../context');
+const { resolveConfiguration } = require('../config');
+const { showUsage } = require('../cli');
+
+async function executeCreate(flags, config, cwd = process.cwd()) {
+  const branch = flags.branch;
+  if (!branch) {
+    console.error('Error: --branch is a required argument for creation.');
+    showUsage();
+    process.exit(1);
+  }
+
+  // 1. Resolve Dirname and Worktree Path
+  const sanitizedBranch = branch.replace(/\//g, '-');
+  const dirname = flags.dirname || sanitizedBranch;
+
+  const repoRoot = git.getRepoRootDir(cwd, config.repo.bareRepo);
+  const baseDir = config.repo.worktreesBase || (git.isBareRepo(repoRoot) ? path.dirname(repoRoot) : repoRoot);
+  const worktreePath = path.resolve(baseDir, dirname);
+
+  // 2. Resolve Session / Workspace Name
+  const baseWorkspace = flags.workspaceName || dirname.replace(/[\s.:]/g, '_');
+  let prefix = config.workspace.labelPrefix || '';
+  let sessionName = (prefix && !baseWorkspace.startsWith(prefix.trim()))
+    ? `${prefix}${baseWorkspace}`
+    : baseWorkspace;
+
+  console.log(`\n=== Starting Herdr Worktree Session ===`);
+  console.log(`Active Preset:        ${config.preset ? config.preset.name : 'generic'}`);
+  console.log(`Repository Root:      ${repoRoot}`);
+  console.log(`Target Worktree Path: ${worktreePath}`);
+  console.log(`Workspace Name:       ${sessionName}`);
+  console.log(`Base Branch (Source): ${flags.source || config.repo.defaultBaseBranch}\n`);
+
+  // 3. Determine if Worktree Already Exists
+  const worktrees = git.getWorktrees({ repoDir: repoRoot, bareRepo: config.repo.bareRepo });
+  const existingWorktree = worktrees.find(wt => wt.branch === branch || path.resolve(wt.path) === path.resolve(worktreePath));
+
+  let worktreePathToUse = worktreePath;
+  let worktreeExists = false;
+
+  if (existingWorktree) {
+    worktreeExists = true;
+    worktreePathToUse = existingWorktree.path;
+    console.log(`Worktree already exists for branch "${branch}" at "${worktreePathToUse}".`);
+  } else if (fs.existsSync(worktreePath)) {
+    worktreeExists = true;
+    console.log(`Directory already exists at "${worktreePath}". Skipping git worktree creation.`);
+  }
+
+  // 4. Create Worktree if it doesn't exist
+  if (!worktreeExists) {
+    console.log(`Creating new git worktree for branch "${branch}"...`);
+    try {
+      git.createWorktree({
+        worktreePath,
+        branch,
+        source: flags.source || config.repo.defaultBaseBranch,
+        repoDir: repoRoot,
+        bareRepo: config.repo.bareRepo,
+      });
+    } catch (err) {
+      console.error(`Failed to create worktree: ${err.message}`);
+      process.exit(1);
+    }
+  }
+
+  // 5. Re-resolve config using target worktree directory for branch-specific overrides
+  const activeConfig = resolveConfiguration(flags, worktreePathToUse);
+  prefix = activeConfig.workspace.labelPrefix || '';
+  sessionName = (prefix && !baseWorkspace.startsWith(prefix.trim()))
+    ? `${prefix}${baseWorkspace}`
+    : baseWorkspace;
+
+  // Initialize Context for Hooks
+  const ctx = createContext({
+    worktreePath: worktreePathToUse,
+    repoRoot,
+    bareRepo: activeConfig.repo.bareRepo,
+    branch,
+    source: flags.source || activeConfig.repo.defaultBaseBranch,
+    flags,
+    preset: activeConfig.preset,
+    config: activeConfig,
+  });
+
+  // 6. Run Preset / Config Hooks
+  if (typeof activeConfig.hooks.onSyncPrimary === 'function') {
+    await activeConfig.hooks.onSyncPrimary(ctx);
+  }
+
+  if (!worktreeExists && typeof activeConfig.hooks.onScaffold === 'function') {
+    await activeConfig.hooks.onScaffold(ctx);
+  }
+
+  // 7. Orchestrate Herdr Workspace
+  await herdr.ensureHerdrInstalled({ yes: flags.yes });
+
+  console.log(`\n==> Creating Herdr workspace "${sessionName}"...`);
+  let ws;
+  try {
+    ws = herdr.createWorkspace({ label: sessionName, cwd: worktreePathToUse });
+  } catch (err) {
+    console.error(`Failed to create herdr workspace: ${err.message}`);
+    process.exit(1);
+  }
+
+  // 8. Render Terminal Layout
+  console.log(`==> Configuring terminal panes...`);
+  layout.renderLayout({
+    layout: activeConfig.layout,
+    rootPaneId: ws.rootPaneId,
+    cwd: worktreePathToUse,
+    focusTarget: flags.focusTarget || activeConfig.workspace.defaultFocus,
+  });
+
+  // Focus the workspace
+  herdr.focusWorkspace(ws.workspaceId);
+
+  // 9. Attach or Switch
+  herdr.attachOrSwitchSession(sessionName);
+}
+
+module.exports = {
+  executeCreate,
+};

package/lib/lifecycle/nuke.js

@@ -0,0 +1,218 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const git = require('../git');
+const herdr = require('../herdr');
+const { createContext } = require('../context');
+const { resolveConfiguration } = require('../config');
+const { showUsage } = require('../cli');
+
+async function executeNuke(flags, config, cwd = process.cwd()) {
+  const repoRoot = git.getRepoRootDir(cwd, config.repo.bareRepo);
+  const worktrees = git.getWorktrees({ repoDir: repoRoot, bareRepo: config.repo.bareRepo });
+
+  let target = flags.cleanupTarget || flags.dirname || flags.branch;
+
+  // 1. Auto-detect worktree if invoked inside a worktree directory without arguments
+  if (!target) {
+    const currentCwd = path.resolve(cwd);
+    const matchingWt = worktrees.find(wt => {
+      if (wt.isBare) return false;
+      const resolvedWtPath = path.resolve(wt.path);
+      return resolvedWtPath !== path.resolve(repoRoot) && (
+        currentCwd === resolvedWtPath ||
+        currentCwd.startsWith(resolvedWtPath + path.sep)
+      );
+    });
+
+    if (matchingWt) {
+      target = matchingWt.path;
+      console.log(`Auto-detected current worktree: "${target}"`);
+    } else {
+      console.error('Error: --nuke / --cleanup requires a worktree directory name or branch when run from the root repository.');
+      showUsage();
+      process.exit(1);
+    }
+  }
+
+  // 2. Resolve worktree target path and matching branch
+  const baseDir = config.repo.worktreesBase || repoRoot;
+  const resolvedTarget = path.isAbsolute(target) ? path.resolve(target) : path.resolve(baseDir, target);
+
+  const existingWorktree = worktrees.find(wt => {
+    return (
+      path.resolve(wt.path) === resolvedTarget ||
+      path.basename(wt.path) === target ||
+      (wt.branch && wt.branch === target) ||
+      (flags.branch && wt.branch === flags.branch)
+    );
+  });
+
+  const targetWorktreePath = existingWorktree ? existingWorktree.path : resolvedTarget;
+  const targetDirname = path.basename(targetWorktreePath);
+  const targetSessionName = targetDirname.replace(/[\s.:]/g, '_');
+
+  const activeConfig = fs.existsSync(targetWorktreePath)
+    ? resolveConfiguration(flags, targetWorktreePath)
+    : config;
+
+  let targetBranch = flags.branch;
+  if (!targetBranch && existingWorktree && existingWorktree.branch) {
+    targetBranch = existingWorktree.branch;
+  }
+  if (!targetBranch && fs.existsSync(targetWorktreePath)) {
+    try {
+      const detected = execSync(`git -C "${targetWorktreePath}" rev-parse --abbrev-ref HEAD`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+      if (detected && detected !== 'HEAD') {
+        targetBranch = detected;
+      }
+    } catch (e) {}
+  }
+  if (!targetBranch) {
+    try {
+      const gitCmd = git.getGitPrefix({ repoDir: repoRoot, bareRepo: activeConfig.repo.bareRepo });
+      execSync(`${gitCmd} rev-parse --verify "${target}"`, { stdio: 'ignore' });
+      targetBranch = target;
+    } catch (e) {}
+  }
+
+  console.log(`\n=== Starting Worktree Nuke ===`);
+  console.log(`Active Preset:        ${activeConfig.preset ? activeConfig.preset.name : 'generic'}`);
+  console.log(`Repository Root:      ${repoRoot}`);
+  console.log(`Target Worktree Path: ${targetWorktreePath}`);
+  console.log(`Associated Branch:    ${targetBranch || '(None detected)'}`);
+  console.log(`Directory Only Mode:  ${flags.dirOnly ? 'Yes (branches will be preserved)' : 'No'}`);
+  console.log(`Keep Remote Branch:   ${flags.keepRemote ? 'Yes' : 'No'}\n`);
+
+  // Safety check: Never delete root repository
+  if (path.resolve(targetWorktreePath) === path.resolve(repoRoot)) {
+    console.error(`Error: Cannot delete the repository root directory "${repoRoot}".`);
+    process.exit(1);
+  }
+
+  // If cwd is inside the target worktree, switch to rootDir/baseDir
+  if (path.resolve(process.cwd()).startsWith(path.resolve(targetWorktreePath))) {
+    console.log(`Current working directory is inside target worktree. Switching to: ${baseDir}`);
+    try {
+      process.chdir(baseDir);
+    } catch (e) {}
+  }
+
+  // Initialize context for hooks
+  const ctx = createContext({
+    worktreePath: targetWorktreePath,
+    repoRoot,
+    bareRepo: activeConfig.repo.bareRepo,
+    branch: targetBranch,
+    flags,
+    preset: activeConfig.preset,
+    config: activeConfig,
+  });
+
+  // Pre-Nuke Hook
+  if (typeof activeConfig.hooks.onPreNuke === 'function') {
+    await activeConfig.hooks.onPreNuke(ctx);
+  }
+
+  // 1. Remove Worktree & Directory
+  console.log(`\n==> [1/3] Removing git worktree and directory...`);
+  const isRegisteredWorktree = worktrees.some(wt => path.resolve(wt.path) === path.resolve(targetWorktreePath));
+
+  if (isRegisteredWorktree) {
+    git.removeWorktree(targetWorktreePath, {
+      force: flags.force,
+      repoDir: repoRoot,
+      bareRepo: config.repo.bareRepo,
+    });
+  }
+
+  // Prune any stale worktree entries
+  git.pruneWorktrees({ repoDir: repoRoot, bareRepo: config.repo.bareRepo });
+
+  // Remove any remaining files or untracked directory
+  if (fs.existsSync(targetWorktreePath)) {
+    console.log(`Removing remaining directory "${targetWorktreePath}"...`);
+    try {
+      fs.rmSync(targetWorktreePath, { recursive: true, force: true });
+      console.log(`Directory deleted successfully.`);
+    } catch (err) {
+      console.error(`Failed to delete directory "${targetWorktreePath}": ${err.message}`);
+    }
+  } else {
+    console.log(`Worktree directory is clean.`);
+  }
+
+  // Helper for final cleanup steps (Herdr workspace close + Post-Nuke hook)
+  const finishCleanup = async () => {
+    // Post-Nuke Hook
+    if (typeof activeConfig.hooks.onPostNuke === 'function') {
+      await activeConfig.hooks.onPostNuke(ctx);
+    }
+
+    // Close Herdr Workspace if running (performed last so active pane is not terminated mid-cleanup)
+    const prefix = activeConfig.workspace.labelPrefix || '';
+    const matchTargets = [
+      targetSessionName,
+      targetDirname,
+      targetBranch,
+      prefix ? `${prefix}${targetSessionName}` : null,
+      prefix ? `${prefix}${targetDirname}` : null,
+    ].filter(Boolean);
+
+    herdr.closeWorkspacesMatching(matchTargets);
+
+    console.log(`\nCleanup complete!`);
+  };
+
+  // 2. Delete Local Branch
+  if (flags.dirOnly) {
+    console.log(`\n==> Skipping branch deletion (--dir-only / --keep-branch).`);
+    await finishCleanup();
+    return;
+  }
+
+  const protectedBranches = activeConfig.repo.protectedBranches || ['main', 'master', 'develop', 'prod', 'staging', 'production'];
+  if (targetBranch && protectedBranches.includes(targetBranch)) {
+    console.warn(`\n==> WARNING: "${targetBranch}" is a protected branch. Skipping local and remote branch deletion.`);
+    await finishCleanup();
+    return;
+  }
+
+  if (!targetBranch) {
+    console.log(`\n==> No branch associated with "${target}". Skipping branch deletion.`);
+    await finishCleanup();
+    return;
+  }
+
+  console.log(`\n==> [2/3] Deleting local branch "${targetBranch}"...`);
+  const gitOpts = { repoDir: repoRoot, bareRepo: config.repo.bareRepo };
+  const existsLocally = git.branchExistsLocally(targetBranch, gitOpts);
+
+  if (existsLocally) {
+    git.deleteLocalBranch(targetBranch, gitOpts);
+  } else {
+    console.log(`Local branch "${targetBranch}" does not exist or was already deleted.`);
+  }
+
+  // 3. Delete Remote Branch
+  if (flags.keepRemote) {
+    console.log(`\n==> Skipping remote branch deletion (--keep-remote / --local-only).`);
+    await finishCleanup();
+    return;
+  }
+
+  console.log(`\n==> [3/3] Deleting remote branch "${targetBranch}" from origin...`);
+  const existsRemotely = git.branchExistsRemotely(targetBranch, gitOpts);
+
+  if (existsRemotely) {
+    git.deleteRemoteBranch(targetBranch, gitOpts);
+  } else {
+    console.log(`Remote branch "${targetBranch}" does not exist on origin or was already deleted.`);
+  }
+
+  await finishCleanup();
+}
+
+module.exports = {
+  executeNuke,
+};

package/lib/skill.js

@@ -0,0 +1,200 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const SKILL_CONTENT = `---
+name: arise
+description: User guide, CLI reference, and command executor for the \`arise\` utility (Git worktree and Herdr workspace orchestrator). Activate this skill whenever the user asks questions about how to use arise, how worktree orchestration works, how to configure \`.ariserc.json\` or \`.worktreerc.json\`, or asks the assistant to create, switch to, or nuke/clean up Git worktrees and Herdr workspaces on their behalf.
+---
+
+# Arise Operator & Assistant Guide
+
+Use this skill to answer questions about \`arise\` and run worktree management commands on the user's behalf.
+
+---
+
+## 1. CLI Quick Reference & Cheatsheet
+
+### Creating Worktrees
+\`\`\`bash
+# Create or open a worktree for a branch (auto-detects preset, boots Herdr workspace)
+arise --branch <branch-name>
+
+# Create worktree based off a specific base branch (e.g. develop, prod, main)
+arise --branch <branch-name> --base <base-branch>
+
+# Custom directory name or workspace name
+arise -b <branch-name> -d <dir-name> -w <workspace-name>
+
+# Explicit preset or pane focus ('agy', 'vim', 'logs', 'server', 'shell')
+arise -b <branch-name> --preset laravel --focus agy
+\`\`\`
+
+### Nuking / Teardown
+\`\`\`bash
+# Nuke active worktree (when run inside a worktree directory)
+arise --nuke
+
+# Nuke specific worktree by branch or directory name
+arise --nuke <branch-or-dir>
+
+# Remove directory only (keep local and remote git branches)
+arise --nuke <target> --dir-only
+
+# Delete local branch and directory, but keep remote branch on origin
+arise --nuke <target> --keep-remote
+
+# Force removal even if uncommitted changes exist
+arise --nuke <target> --force
+\`\`\`
+
+---
+
+## 2. Configuration (\`.ariserc.json\` / \`.worktreerc.json\` / \`arise.config.js\`)
+
+Projects can configure custom topology, bare repos, and layouts via \`.ariserc.json\` or \`.worktreerc.json\` in the repository root or base directory:
+
+\`\`\`json
+{
+  "preset": "laravel",
+  "repo": {
+    "bareRepo": "/path/to/bare.git",
+    "worktreesBase": "/path/to/worktrees",
+    "defaultBaseBranch": "develop",
+    "protectedBranches": ["main", "master", "develop", "prod", "staging"]
+  },
+  "workspace": {
+    "labelPrefix": "[API] ",
+    "defaultFocus": "agy"
+  },
+  "scaffold": {
+    "envSource": "/path/to/shared/.env",
+    "symlink": "/path/to/webserver/symlink",
+    "install": "composer install --no-interaction"
+  }
+}
+\`\`\`
+
+---
+
+## 3. How to Assist the User
+
+### When the User Asks Questions:
+1. Consult the CLI options and configuration schema above.
+2. If working inside a repository with local documentation or \`.ariserc.json\` / \`.worktreerc.json\`, inspect those files.
+3. Provide clear explanations with executable CLI examples and config snippets.
+
+### When the User Asks You to Perform an Action:
+1. Formulate the appropriate \`arise\` CLI command.
+2. Execute the command on behalf of the user using the available command runner.
+3. Confirm the status of the created or nuked worktree and Herdr workspace.
+`;
+
+function ensureSourceSkillExists(repoRoot) {
+  const sourceDir = path.join(repoRoot, 'skills', 'arise');
+  const sourceFile = path.join(sourceDir, 'SKILL.md');
+  if (fs.existsSync(sourceFile)) {
+    return sourceDir;
+  }
+  try {
+    fs.mkdirSync(sourceDir, { recursive: true });
+    fs.writeFileSync(sourceFile, SKILL_CONTENT, 'utf8');
+  } catch (err) {
+    // Proceed with sourceDir even if write fails (e.g. read-only global node_modules)
+  }
+  return sourceDir;
+}
+
+function safeSymlink(target, linkPath) {
+  try {
+    if (fs.existsSync(linkPath) || fs.lstatSync(linkPath).isSymbolicLink()) {
+      fs.rmSync(linkPath, { recursive: true, force: true });
+    }
+  } catch (err) {
+    // If doesn't exist, proceed
+  }
+  fs.symlinkSync(target, linkPath, 'dir');
+}
+
+function installSkill(options = {}) {
+  const scope = options.scope || 'global';
+  const cwd = options.cwd || process.cwd();
+  const homedir = options.homedir || os.homedir();
+  const repoRoot = options.repoRoot || path.resolve(__dirname, '..');
+
+  const sourceDir = ensureSourceSkillExists(repoRoot);
+  const installedPaths = [];
+
+  if (scope === 'local' || scope === 'workspace') {
+    const localAgentsSkillsDir = path.join(cwd, '.agents', 'skills');
+    fs.mkdirSync(localAgentsSkillsDir, { recursive: true });
+    const localLink = path.join(localAgentsSkillsDir, 'arise');
+
+    try {
+      safeSymlink(sourceDir, localLink);
+      installedPaths.push(localLink);
+      console.log(`✓ Symlinked local agent skill: ${localLink} -> ${sourceDir}`);
+    } catch (err) {
+      // Fallback to direct file copy if symlink creation fails
+      const fallbackFile = path.join(localLink, 'SKILL.md');
+      fs.mkdirSync(localLink, { recursive: true });
+      fs.writeFileSync(fallbackFile, SKILL_CONTENT, 'utf8');
+      installedPaths.push(fallbackFile);
+      console.log(`✓ Installed local agent skill (copy): ${fallbackFile}`);
+    }
+  } else {
+    // Universal ~/.agents/skills/ directory
+    const globalAgentsSkillsDir = path.join(homedir, '.agents', 'skills');
+    fs.mkdirSync(globalAgentsSkillsDir, { recursive: true });
+    const globalAgentsLink = path.join(globalAgentsSkillsDir, 'arise');
+
+    try {
+      safeSymlink(sourceDir, globalAgentsLink);
+      installedPaths.push(globalAgentsLink);
+      console.log(`✓ Symlinked global agent skill: ${globalAgentsLink} -> ${sourceDir}`);
+    } catch (err) {
+      // Fallback to copy if symlink permissions fail
+      const fallbackDir = path.join(globalAgentsSkillsDir, 'arise');
+      fs.mkdirSync(fallbackDir, { recursive: true });
+      const targetFile = path.join(fallbackDir, 'SKILL.md');
+      fs.writeFileSync(targetFile, SKILL_CONTENT, 'utf8');
+      installedPaths.push(targetFile);
+      console.log(`✓ Installed global agent skill (copy): ${targetFile}`);
+    }
+
+    // Link ~/.gemini/skills/arise for Antigravity CLI (agy)
+    const geminiSkillsDir = path.join(homedir, '.gemini', 'skills');
+    try {
+      fs.mkdirSync(geminiSkillsDir, { recursive: true });
+      const geminiLink = path.join(geminiSkillsDir, 'arise');
+      safeSymlink(globalAgentsLink, geminiLink);
+      installedPaths.push(geminiLink);
+      console.log(`✓ Linked to Antigravity skills: ${geminiLink} -> ${globalAgentsLink}`);
+    } catch (err) {
+      // Non-fatal
+    }
+
+    // Link ~/.claude/skills/arise if Claude exists
+    const claudeDir = path.join(homedir, '.claude');
+    if (fs.existsSync(claudeDir)) {
+      try {
+        const claudeSkillsDir = path.join(claudeDir, 'skills');
+        fs.mkdirSync(claudeSkillsDir, { recursive: true });
+        const claudeLink = path.join(claudeSkillsDir, 'arise');
+        safeSymlink(globalAgentsLink, claudeLink);
+        installedPaths.push(claudeLink);
+        console.log(`✓ Linked to Claude skills: ${claudeLink} -> ${globalAgentsLink}`);
+      } catch (err) {
+        // Non-fatal
+      }
+    }
+  }
+
+  return installedPaths;
+}
+
+module.exports = {
+  SKILL_CONTENT,
+  ensureSourceSkillExists,
+  installSkill,
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@tsuzuku/arise",
+  "version": "0.2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Arise - Unified workplace-agnostic Git worktree and Herdr workspace orchestrator with pluggable project presets",
+  "main": "index.js",
+  "bin": {
+    "arise": "bin/cli.js",
+    "herdr-worktree": "bin/cli.js",
+    "herder-worktree": "bin/cli.js",
+    "hwk": "bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "presets",
+    "skills",
+    "index.js",
+    "types.d.ts",
+    "arise.schema.json",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.js"
+  },
+  "keywords": [
+    "git",
+    "worktree",
+    "herdr",
+    "workspace",
+    "laravel",
+    "node",
+    "cli"
+  ],
+  "author": "",
+  "license": "ISC"
+}