@xmem-ai/memcode 4.0.2

package/dist/skills/bundled/batch.js

@@ -0,0 +1,125 @@
+import { AGENT_TOOL_NAME } from "../../tools/AgentTool/constants.js";
+import { ASK_USER_QUESTION_TOOL_NAME } from "../../tools/AskUserQuestionTool/prompt.js";
+import { ENTER_PLAN_MODE_TOOL_NAME } from "../../tools/EnterPlanModeTool/constants.js";
+import { EXIT_PLAN_MODE_TOOL_NAME } from "../../tools/ExitPlanModeTool/constants.js";
+import { SKILL_TOOL_NAME } from "../../tools/SkillTool/constants.js";
+import { getIsGit } from "../../utils/git.js";
+import { registerBundledSkill } from "../bundledSkills.js";
+const MIN_AGENTS = 5;
+const MAX_AGENTS = 30;
+const WORKER_INSTRUCTIONS = `After you finish implementing the change:
+1. **Simplify** - Invoke the \`${SKILL_TOOL_NAME}\` tool with \`skill: "simplify"\` to review and clean up your changes.
+2. **Run unit tests** - Run the project's test suite (check for package.json scripts, Makefile targets, or common commands like \`npm test\`, \`bun test\`, \`pytest\`, \`go test\`). If tests fail, fix them.
+3. **Test end-to-end** - Follow the e2e test recipe from the coordinator's prompt (below). If the recipe says to skip e2e for this unit, skip it.
+4. **Commit and push** - Commit all changes with a clear message, push the branch, and create a PR with \`gh pr create\`. Use a descriptive title. If \`gh\` is not available or the push fails, note it in your final message.
+5. **Report** - End with a single line: \`PR: <url>\` so the coordinator can track it. If no PR was created, end with \`PR: none - <reason>\`.`;
+function buildPrompt(instruction) {
+  return `# Batch: Parallel Work Orchestration
+
+You are orchestrating a large, parallelizable change across this codebase.
+
+## User Instruction
+
+${instruction}
+
+## Phase 1: Research and Plan (Plan Mode)
+
+Call the \`${ENTER_PLAN_MODE_TOOL_NAME}\` tool now to enter plan mode, then:
+
+1. **Understand the scope.** Launch one or more subagents (in the foreground - you need their results) to deeply research what this instruction touches. Find all the files, patterns, and call sites that need to change. Understand the existing conventions so the migration is consistent.
+
+2. **Decompose into independent units.** Break the work into ${MIN_AGENTS}-${MAX_AGENTS} self-contained units. Each unit must:
+   - Be independently implementable in an isolated git worktree (no shared state with sibling units)
+   - Be mergeable on its own without depending on another unit's PR landing first
+   - Be roughly uniform in size (split large units, merge trivial ones)
+
+   Scale the count to the actual work: few files -> closer to ${MIN_AGENTS}; hundreds of files -> closer to ${MAX_AGENTS}. Prefer per-directory or per-module slicing over arbitrary file lists.
+
+3. **Determine the e2e test recipe.** Figure out how a worker can verify its change actually works end-to-end - not just that unit tests pass. Look for:
+   - A browser-automation tool (for UI changes: click through the affected flow, screenshot the result)
+   - A \`tmux\` or CLI-verifier skill (for CLI changes: launch the app interactively, exercise the changed behavior)
+   - A dev-server + curl pattern (for API changes: start the server, hit the affected endpoints)
+   - An existing e2e/integration test suite the worker can run
+
+   If you cannot find a concrete e2e path, use the \`${ASK_USER_QUESTION_TOOL_NAME}\` tool to ask the user how to verify this change end-to-end. Offer 2-3 specific options based on what you found (e.g., "Screenshot via chrome extension", "Run \`bun run dev\` and curl the endpoint", "No e2e - unit tests are sufficient"). Do not skip this - the workers cannot ask the user themselves.
+
+   Write the recipe as a short, concrete set of steps that a worker can execute autonomously. Include any setup (start a dev server, build first) and the exact command/interaction to verify.
+
+4. **Write the plan.** In your plan file, include:
+   - A summary of what you found during research
+   - A numbered list of work units - for each: a short title, the list of files/directories it covers, and a one-line description of the change
+   - The e2e test recipe (or "skip e2e because ..." if the user chose that)
+   - The exact worker instructions you will give each agent (the shared template)
+
+5. Call \`${EXIT_PLAN_MODE_TOOL_NAME}\` to present the plan for approval.
+
+## Phase 2: Spawn Workers (After Plan Approval)
+
+Once the plan is approved, spawn one background agent per work unit using the \`${AGENT_TOOL_NAME}\` tool. **All agents must use \`isolation: "worktree"\` and \`run_in_background: true\`.** Launch them all in a single message block so they run in parallel.
+
+For each agent, the prompt must be fully self-contained. Include:
+- The overall goal (the user's instruction)
+- This unit's specific task (title, file list, change description - copied verbatim from your plan)
+- Any codebase conventions you discovered that the worker needs to follow
+- The e2e test recipe from your plan (or "skip e2e because ...")
+- The worker instructions below, copied verbatim:
+
+\`\`\`
+${WORKER_INSTRUCTIONS}
+\`\`\`
+
+Use \`subagent_type: "general-purpose"\` unless a more specific agent type fits.
+
+## Phase 3: Track Progress
+
+After launching all workers, render an initial status table:
+
+| # | Unit | Status | PR |
+|---|------|--------|----|
+| 1 | <title> | running | - |
+| 2 | <title> | running | - |
+
+As background-agent completion notifications arrive, parse the \`PR: <url>\` line from each agent's result and re-render the table with updated status (\`done\` / \`failed\`) and PR links. Keep a brief failure note for any agent that did not produce a PR.
+
+When all agents have reported, render the final table and a one-line summary (e.g., "22/24 units landed as PRs").
+`;
+}
+const NOT_A_GIT_REPO_MESSAGE = `This is not a git repository. The \`/batch\` command requires a git repo because it spawns agents in isolated git worktrees and creates PRs from each. Initialize a repo first, or run this from inside an existing one.`;
+const MISSING_INSTRUCTION_MESSAGE = `Provide an instruction describing the batch change you want to make.
+
+Examples:
+  /batch migrate from react to vue
+  /batch replace all uses of lodash with native equivalents
+  /batch add type annotations to all untyped function parameters`;
+function registerBatchSkill() {
+  registerBundledSkill({
+    name: "batch",
+    description: "Research and plan a large-scale change, then execute it in parallel across 5-30 isolated worktree agents that each open a PR.",
+    whenToUse: "Use when the user wants to make a sweeping, mechanical change across many files (migrations, refactors, bulk renames) that can be decomposed into independent parallel units.",
+    argumentHint: "<instruction>",
+    allowedTools: [
+      "EnterPlanMode",
+      "ExitPlanMode",
+      "Agent",
+      "AskUserQuestion",
+      "Skill",
+      "Bash(git:*)"
+    ],
+    userInvocable: true,
+    disableModelInvocation: true,
+    async getPromptForCommand(args) {
+      const instruction = args.trim();
+      if (!instruction) {
+        return [{ type: "text", text: MISSING_INSTRUCTION_MESSAGE }];
+      }
+      const isGit = await getIsGit();
+      if (!isGit) {
+        return [{ type: "text", text: NOT_A_GIT_REPO_MESSAGE }];
+      }
+      return [{ type: "text", text: buildPrompt(instruction) }];
+    }
+  });
+}
+export {
+  registerBatchSkill
+};

package/dist/skills/bundled/debug.js

@@ -0,0 +1,91 @@
+import { open, stat } from "fs/promises";
+import { getSettingsFilePathForSource } from "src/utils/settings/settings.js";
+import { enableDebugLogging, getDebugLogPath } from "../../utils/debug.js";
+import { errorMessage, isENOENT } from "../../utils/errors.js";
+import { formatFileSize } from "../../utils/format.js";
+import { registerBundledSkill } from "../bundledSkills.js";
+const DEFAULT_DEBUG_LINES_READ = 20;
+const TAIL_READ_BYTES = 64 * 1024;
+function registerDebugSkill() {
+  registerBundledSkill({
+    name: "debug",
+    description: "Enable memCode trace logging for this session and diagnose issues",
+    allowedTools: ["Read", "Grep", "Glob"],
+    argumentHint: "[issue description]",
+    // disableModelInvocation so that the user has to explicitly request it in
+    // interactive mode and so the description does not take up context.
+    disableModelInvocation: true,
+    userInvocable: true,
+    async getPromptForCommand(args) {
+      const wasAlreadyLogging = enableDebugLogging();
+      const debugLogPath = getDebugLogPath();
+      let logInfo;
+      try {
+        const stats = await stat(debugLogPath);
+        const readSize = Math.min(stats.size, TAIL_READ_BYTES);
+        const startOffset = stats.size - readSize;
+        const fd = await open(debugLogPath, "r");
+        try {
+          const { buffer, bytesRead } = await fd.read({
+            buffer: Buffer.alloc(readSize),
+            position: startOffset
+          });
+          const tail = buffer.toString("utf-8", 0, bytesRead).split("\n").slice(-DEFAULT_DEBUG_LINES_READ).join("\n");
+          logInfo = `Log size: ${formatFileSize(stats.size)}
+
+### Last ${DEFAULT_DEBUG_LINES_READ} lines
+
+\`\`\`
+${tail}
+\`\`\``;
+        } finally {
+          await fd.close();
+        }
+      } catch (e) {
+        logInfo = isENOENT(e) ? "No debug log exists yet \u2014 logging was just enabled." : `Failed to read last ${DEFAULT_DEBUG_LINES_READ} lines of debug log: ${errorMessage(e)}`;
+      }
+      const justEnabledSection = wasAlreadyLogging ? "" : `
+## Trace Logging Just Enabled
+
+Trace logging was OFF for this session until now. Nothing prior to this /debug invocation was captured.
+
+Tell the user that trace logging is now active at \`${debugLogPath}\`, ask them to reproduce the issue, then re-read the log. If they can't reproduce, they can also restart with \`memcode --debug\` to capture logs from startup.
+`;
+      const prompt = `# memCode Trace Kit
+
+Help the user debug an issue they're encountering in this current memCode session.
+${justEnabledSection}
+## Session Debug Log
+
+The debug log for the current session is at: \`${debugLogPath}\`
+
+${logInfo}
+
+For additional context, grep for [ERROR] and [WARN] lines across the full file.
+
+## Issue Description
+
+${args || "The user did not describe a specific issue. Read the debug log and summarize any errors, warnings, or notable issues."}
+
+## Settings
+
+Remember that settings are in:
+* user - ${getSettingsFilePathForSource("userSettings")}
+* project - ${getSettingsFilePathForSource("projectSettings")}
+* local - ${getSettingsFilePathForSource("localSettings")}
+
+## Instructions
+
+1. Review the user's issue description
+2. The last ${DEFAULT_DEBUG_LINES_READ} lines show the debug file format. Look for [ERROR] and [WARN] entries, stack traces, and failure patterns across the file
+3. Review the relevant memCode code paths or documentation needed to understand the feature
+4. Explain what you found in plain language
+5. Suggest concrete fixes or next steps
+`;
+      return [{ type: "text", text: prompt }];
+    }
+  });
+}
+export {
+  registerDebugSkill
+};

package/dist/skills/bundled/github-auth-check/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: github-auth-check
+description: Check whether GitHub is usable from the terminal by inspecting git remotes, gh CLI availability, gh authentication, repository permissions, and common auth failures. Use when the user asks to set up GitHub, check GitHub access, diagnose gh auth, verify repo permissions, or prepare for GitHub PR/issue/CI/release work.
+---
+
+# GitHub Auth Check
+
+Determine whether the current repository can use GitHub from the terminal.
+
+## Workflow
+
+1. Run terminal checks yourself. Do not ask the user to run `gh`, `git`, or shell commands when you can run them with available tools.
+2. Inspect local repository state with read-only commands first: current directory, `git status --short --branch`, and `git remote -v`.
+3. Check whether `gh` is installed with `gh --version`.
+4. Check authentication with `gh auth status`.
+5. If authenticated, inspect repository access with `gh repo view` and, when relevant, `gh api user`.
+6. If the repo has no GitHub remote, explain that GitHub operations need a remote such as `origin`.
+7. If auth is missing or expired and this skill was invoked for setup/login/auth, start the login flow yourself with `gh auth login --hostname github.com --git-protocol https --web`.
+8. If login requires user browser/device-code action, report the exact prompt from `gh` and wait for the user to complete that external step. Do not claim auth succeeded until `gh auth status` passes afterward.
+9. Do not create tokens, write credentials manually, or change remotes unless the user explicitly asks.
+
+## Report
+
+State:
+
+- whether `gh` is installed
+- whether the user is authenticated
+- which GitHub account is active, if visible
+- which repository remote is being used
+- what GitHub operations are ready or blocked
+- the exact next step for any blocker

package/dist/skills/bundled/github-ci-fix/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: github-ci-fix
+description: Debug and fix failing GitHub Actions or PR checks by inspecting failed jobs, reading logs, identifying the root cause, making focused fixes, and verifying locally. Use when the user says CI failed, checks are red, GitHub Actions is broken, or asks to fix a failing PR workflow.
+---
+
+# GitHub CI Fix
+
+Find the real failing check and fix it with local evidence.
+
+## Workflow
+
+1. Identify the relevant PR or branch with `gh pr status`, `gh pr view`, or local branch state.
+2. Inspect check status with `gh pr checks` or `gh run list`.
+3. Open failed job logs with `gh run view --log-failed` or the narrowest available log command.
+4. Extract the first meaningful failure, not just the final cascade.
+5. Map the failure to code, tests, configuration, or environment.
+6. Implement a focused fix only when the root cause is in the repo and in scope.
+7. Run the matching local command. If the CI-only environment cannot be reproduced, state the closest local evidence.
+
+## Rules
+
+- Do not rerun workflows, cancel runs, or change branch protection unless explicitly requested.
+- Do not mask failing tests by deleting coverage, weakening assertions, or skipping checks unless the user explicitly asks and the reason is documented.
+- If logs require authentication or are unavailable, report the blocker and the exact command the user can run after login.

package/dist/skills/bundled/github-orient/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: github-orient
+description: Orient on a GitHub repository, branch, pull request, or issue by inspecting local git state plus GitHub metadata. Use when the user asks to summarize a repo, understand an issue or PR, inspect branch status, compare with remote, or figure out what GitHub work is pending.
+---
+
+# GitHub Orient
+
+Build a concise, evidence-backed picture of the current GitHub context.
+
+## Workflow
+
+1. Start with local state: `git status --short --branch`, current branch, remotes, and recent commits.
+2. Use `gh repo view` to identify the GitHub owner/repo when `gh` is available.
+3. For PR context, use `gh pr status`, `gh pr view --json ...`, or `gh pr list` as appropriate.
+4. For issue context, use `gh issue view` or `gh issue list` with focused filters.
+5. Compare local and remote only when useful; fetch first if freshness matters and the user has allowed network access.
+6. Keep the output short and actionable. Mention uncertainties instead of inventing missing GitHub state.
+7. Do not switch into PR creation, commit, push, or release workflows unless the user explicitly asked for that. This skill orients; it does not execute the next workflow.
+
+## Report
+
+Include:
+
+- current branch and dirty/clean state
+- upstream/remote relationship
+- active PR or issue, if found
+- latest relevant commits
+- blockers or missing authentication
+- one recommended next action, phrased as a statement rather than a closing question

package/dist/skills/bundled/github-pr/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: github-pr
+description: Prepare, create, or update GitHub pull requests from terminal context. Use when the user asks to open a PR, create a draft PR, push a branch, update PR title/body, add reviewers or labels, summarize a diff for a PR, or get a branch ready for review.
+---
+
+# GitHub PR
+
+Help the user create or update a pull request safely.
+
+## Workflow
+
+1. Inspect `git status --short --branch` and `git diff`/`git diff --stat` before proposing PR content.
+2. If there are unstaged or uncommitted changes, do not commit them unless the user explicitly asked for commit/push/PR creation.
+3. Identify base and head branches with `git branch --show-current`, upstream info, and `gh pr status` or `gh pr view`.
+4. If creating a PR, push the branch only after confirming the intended branch and ensuring the commit set is appropriate.
+5. Use `gh pr create --draft` by default unless the user clearly asks for a ready-for-review PR.
+6. Generate a concise PR title and body from actual diffs and commits. Do not claim tests passed unless they were run.
+7. For updating an existing PR, prefer `gh pr edit` and keep existing useful body content unless the user asks to replace it.
+
+## PR Body Shape
+
+Use this shape unless the repo already has a template:
+
+```markdown
+## Summary
+- ...
+
+## Tests
+- ...
+```
+
+## Safety
+
+- Do not force-push, merge, close, or delete branches unless explicitly requested.
+- Do not include secrets, tokens, or private command output in PR text.
+- If GitHub auth is missing, stop and provide the exact auth/setup command.

package/dist/skills/bundled/github-release/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: github-release
+description: Prepare GitHub release work by inspecting tags, versions, commits, changelog needs, and release status. Use when the user asks to draft a release, create a changelog, tag a version, publish a GitHub release, compare releases, or prepare release notes.
+---
+
+# GitHub Release
+
+Prepare release notes, tags, and GitHub releases from repository evidence.
+
+## Workflow
+
+1. Inspect current branch, dirty state, package/version files, and latest tags.
+2. Compare commits since the previous tag with `git log` or `gh release view/list` when GitHub metadata matters.
+3. Draft release notes from actual commits, merged PRs, and changed files.
+4. If version files need updates, treat that as a code change and verify the repo's normal checks.
+5. Create tags or GitHub releases only when the user explicitly asks.
+6. Prefer draft releases unless the user explicitly asks to publish.
+
+## Rules
+
+- Do not publish, tag, or push release commits without explicit user intent.
+- Do not invent semantic version bumps; infer from repo policy when documented, otherwise ask or state the assumption.
+- Include verification status and any unverified risk in the release summary.

package/dist/skills/bundled/github-review-fix/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: github-review-fix
+description: Address GitHub pull request review feedback by fetching review comments, mapping them to files, implementing requested changes, and reporting what was fixed. Use when the user asks to fix PR comments, address review feedback, handle requested changes, or inspect unresolved GitHub review threads.
+---
+
+# GitHub Review Fix
+
+Turn PR review feedback into focused code changes.
+
+## Workflow
+
+1. Identify the PR with `gh pr view` or the PR number/URL in the user request.
+2. Fetch review comments with `gh pr view --comments` and, when available, API/GraphQL fields that include file paths and line numbers.
+3. Separate actionable requested changes from praise, questions, and already-resolved discussion.
+4. Inspect the referenced files before editing.
+5. Make the smallest code changes that satisfy the comments while preserving nearby style.
+6. Run focused checks for the touched behavior.
+7. Summarize each addressed comment and the verification evidence.
+
+## Rules
+
+- Do not resolve, dismiss, or reply to review threads unless the user explicitly asks.
+- Do not rewrite unrelated code while addressing comments.
+- If a comment is ambiguous, state the ambiguity and choose the safest narrow fix when possible.
+- If a requested change conflicts with project behavior, explain the conflict instead of forcing the edit.

package/dist/skills/bundled/github.js

@@ -0,0 +1,90 @@
+import { parseFrontmatter } from "../../utils/frontmatterParser.js";
+import { registerBundledSkill } from "../bundledSkills.js";
+import { GITHUB_SUBSKILLS } from "./githubContent.js";
+const GITHUB_DESCRIPTION = "Use GitHub from the terminal through focused sub-actions for auth checks, repository/PR/issue orientation, pull requests, review comment fixes, CI fixes, and releases. Use when the user asks for GitHub setup, repo status, PR creation/update, review feedback, failing GitHub Actions, changelogs, tags, or releases.";
+const MENU = `# GitHub
+
+Use the requested GitHub sub-action.
+
+## Sub-actions
+
+- \`auth\`: check gh installation, login, remotes, and repo access
+- \`orient\`: inspect repo, branch, issue, or PR context
+- \`pr\`: prepare, push, create, or update a pull request
+- \`review-fix\`: address PR review comments and requested changes
+- \`ci-fix\`: debug and fix failing GitHub Actions/checks
+- \`release\`: prepare changelogs, tags, and GitHub releases
+
+## Usage
+
+\`/github <sub-action> [task]\`
+
+Examples:
+
+- \`/github auth\`
+- \`/github orient current PR\`
+- \`/github pr create draft\`
+- \`/github review-fix PR 123\`
+- \`/github ci-fix latest failed run\`
+- \`/github release draft notes\`
+`;
+const COMMON_GITHUB_INSTRUCTIONS = `## GitHub Tool Use
+
+Run GitHub and git terminal commands yourself with available tools. Do not ask the user to run \`gh\`, \`git\`, or shell commands unless an interactive browser/device-code step, missing installation, or permission boundary prevents you from doing it directly.
+
+## Output Style
+
+- Reply in English unless the user explicitly asks for another language.
+- Use plain Markdown bullets or short sections. Do not use box-drawing tables or decorative Unicode borders.
+- Keep the result scoped to the selected GitHub sub-action. For \`orient\`, summarize status and recommend one next action; do not ask to commit, push, or create a PR unless the user requested that workflow.
+- Do not include token values or secrets. If command output contains a token, mention only that authentication is present and scopes are available.
+`;
+function splitSubcommand(args) {
+  const trimmed = args.trim();
+  if (!trimmed) return { rest: "" };
+  const [first = "", ...rest] = trimmed.split(/\s+/);
+  const normalized = first.toLowerCase();
+  const subskill = GITHUB_SUBSKILLS.find(
+    (skill) => skill.key === normalized || skill.aliases.includes(normalized)
+  );
+  if (!subskill) return { rest: trimmed };
+  return { key: subskill.key, rest: rest.join(" ") };
+}
+function registerGithubSkills() {
+  registerBundledSkill({
+    name: "github",
+    description: GITHUB_DESCRIPTION,
+    argumentHint: "<auth|orient|pr|review-fix|ci-fix|release> [task]",
+    subcommands: GITHUB_SUBSKILLS.map((skill) => ({
+      name: skill.key,
+      aliases: [...skill.aliases],
+      description: skill.description,
+      argumentHint: skill.argumentHint
+    })),
+    userInvocable: true,
+    async getPromptForCommand(args) {
+      const { key, rest } = splitSubcommand(args);
+      if (!key) {
+        const text = args.trim() ? `${MENU}
+
+## User Request
+
+${args.trim()}` : MENU;
+        return [{ type: "text", text }];
+      }
+      const subskill = GITHUB_SUBSKILLS.find((skill) => skill.key === key);
+      if (!subskill) return [{ type: "text", text: MENU }];
+      const { content } = parseFrontmatter(subskill.skillMd);
+      const parts = [COMMON_GITHUB_INSTRUCTIONS, content.trimStart()];
+      if (rest) {
+        parts.push(`## User Request
+
+${rest}`);
+      }
+      return [{ type: "text", text: parts.join("\n\n") }];
+    }
+  });
+}
+export {
+  registerGithubSkills
+};

package/dist/skills/bundled/githubContent.js

@@ -0,0 +1,59 @@
+import authCheckMd from "./github-auth-check/SKILL.md";
+import ciFixMd from "./github-ci-fix/SKILL.md";
+import orientMd from "./github-orient/SKILL.md";
+import prMd from "./github-pr/SKILL.md";
+import releaseMd from "./github-release/SKILL.md";
+import reviewFixMd from "./github-review-fix/SKILL.md";
+const GITHUB_SUBSKILLS = [
+  {
+    key: "auth",
+    aliases: ["auth-check", "check", "setup", "login"],
+    description: "Check gh install, login, remotes, and repo access",
+    argumentHint: "[what to check]",
+    fallbackDescription: "Check local GitHub CLI authentication and repository access.",
+    skillMd: authCheckMd
+  },
+  {
+    key: "orient",
+    aliases: ["status", "repo", "issue", "inspect"],
+    description: "Inspect repo, branch, issue, or PR context",
+    argumentHint: "[repo|branch|PR|issue]",
+    fallbackDescription: "Inspect GitHub repository, branch, issue, or pull request context.",
+    skillMd: orientMd
+  },
+  {
+    key: "pr",
+    aliases: ["pull-request", "pullrequest", "draft"],
+    description: "Prepare, create, or update a pull request",
+    argumentHint: "[create draft|update|summarize]",
+    fallbackDescription: "Prepare, push, create, or update a GitHub pull request.",
+    skillMd: prMd
+  },
+  {
+    key: "review-fix",
+    aliases: ["review", "comments", "pr-comments", "requested-changes"],
+    description: "Address PR review comments and requested changes",
+    argumentHint: "[PR number or URL]",
+    fallbackDescription: "Address GitHub pull request review comments.",
+    skillMd: reviewFixMd
+  },
+  {
+    key: "ci-fix",
+    aliases: ["ci", "checks", "actions", "workflow"],
+    description: "Debug and fix failing GitHub Actions or checks",
+    argumentHint: "[run|PR|branch]",
+    fallbackDescription: "Debug and fix failing GitHub Actions checks.",
+    skillMd: ciFixMd
+  },
+  {
+    key: "release",
+    aliases: ["tag", "changelog", "notes"],
+    description: "Prepare changelogs, tags, and GitHub releases",
+    argumentHint: "[draft notes|tag|publish]",
+    fallbackDescription: "Prepare GitHub changelogs, tags, and releases.",
+    skillMd: releaseMd
+  }
+];
+export {
+  GITHUB_SUBSKILLS
+};

package/dist/skills/bundled/index.js

@@ -0,0 +1,40 @@
+import { feature } from "bun:bundle";
+import { isEnvTruthy } from "src/utils/envUtils.js";
+import { registerAssistantRoomSkill } from "./assistantRoom.js";
+import { registerBatchSkill } from "./batch.js";
+import { registerBackgroundSessionSkill } from "./backgroundSession.js";
+import { registerDebugSkill } from "./debug.js";
+import { registerGithubSkills } from "./github.js";
+import { registerKeybindingsSkill } from "./keybindings.js";
+import { registerLoremIpsumSkill } from "./loremIpsum.js";
+import { registerRememberSkill } from "./remember.js";
+import { registerSimplifySkill } from "./simplify.js";
+import { registerSkillifySkill } from "./skillify.js";
+import { registerStuckSkill } from "./stuck.js";
+import { registerUpdateConfigSkill } from "./updateConfig.js";
+import { registerVerifySkill } from "./verify.js";
+function initBundledSkills() {
+  registerDebugSkill();
+  registerBackgroundSessionSkill();
+  registerAssistantRoomSkill();
+  const extraSkillsEnabled = process.env.XCODE_ENABLE_EXTRA_SKILLS === void 0 ? true : isEnvTruthy(process.env.XCODE_ENABLE_EXTRA_SKILLS);
+  if (extraSkillsEnabled) {
+    registerVerifySkill();
+    registerSimplifySkill();
+    registerBatchSkill();
+    registerStuckSkill();
+    registerUpdateConfigSkill();
+    registerKeybindingsSkill();
+    registerLoremIpsumSkill();
+    registerSkillifySkill();
+    registerRememberSkill();
+    registerGithubSkills();
+  }
+  if (extraSkillsEnabled && feature("AGENT_TRIGGERS")) {
+    const { registerLoopSkill } = require("./loop.js");
+    registerLoopSkill();
+  }
+}
+export {
+  initBundledSkills
+};