lcclaude 1.0.0

package/dist/src/skills/bundled/scheduleRemoteAgents.js

@@ -0,0 +1,360 @@
+import { getFeatureValue_CACHED_MAY_BE_STALE } from "../../services/analytics/growthbook.js";
+import { isPolicyAllowed } from "../../services/policyLimits/index.js";
+import { ASK_USER_QUESTION_TOOL_NAME } from "../../tools/AskUserQuestionTool/prompt.js";
+import { REMOTE_TRIGGER_TOOL_NAME } from "../../tools/RemoteTriggerTool/prompt.js";
+import { getClaudeAIOAuthTokens } from "../../utils/auth.js";
+import { checkRepoForRemoteAccess } from "../../utils/background/remote/preconditions.js";
+import { logForDebugging } from "../../utils/debug.js";
+import {
+  detectCurrentRepositoryWithHost,
+  parseGitRemote
+} from "../../utils/detectRepository.js";
+import { getRemoteUrl } from "../../utils/git.js";
+import { jsonStringify } from "../../utils/slowOperations.js";
+import {
+  createDefaultCloudEnvironment,
+  fetchEnvironments
+} from "../../utils/teleport/environments.js";
+import { registerBundledSkill } from "../bundledSkills.js";
+const BASE58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function taggedIdToUUID(taggedId) {
+  const prefix = "mcpsrv_";
+  if (!taggedId.startsWith(prefix)) {
+    return null;
+  }
+  const rest = taggedId.slice(prefix.length);
+  const base58Data = rest.slice(2);
+  let n = 0n;
+  for (const c of base58Data) {
+    const idx = BASE58.indexOf(c);
+    if (idx === -1) {
+      return null;
+    }
+    n = n * 58n + BigInt(idx);
+  }
+  const hex = n.toString(16).padStart(32, "0");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+function getConnectedClaudeAIConnectors(mcpClients) {
+  const connectors = [];
+  for (const client of mcpClients) {
+    if (client.type !== "connected") {
+      continue;
+    }
+    if (client.config.type !== "claudeai-proxy") {
+      continue;
+    }
+    const uuid = taggedIdToUUID(client.config.id);
+    if (!uuid) {
+      continue;
+    }
+    connectors.push({
+      uuid,
+      name: client.name,
+      url: client.config.url
+    });
+  }
+  return connectors;
+}
+function sanitizeConnectorName(name) {
+  return name.replace(/^claude[.\s-]ai[.\s-]/i, "").replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function formatConnectorsInfo(connectors) {
+  if (connectors.length === 0) {
+    return "No connected MCP connectors found. The user may need to connect servers at https://claude.ai/settings/connectors";
+  }
+  const lines = ["Connected connectors (available for triggers):"];
+  for (const c of connectors) {
+    const safeName = sanitizeConnectorName(c.name);
+    lines.push(`- ${c.name} (connector_uuid: ${c.uuid}, name: ${safeName}, url: ${c.url})`);
+  }
+  return lines.join(`
+`);
+}
+const BASE_QUESTION = "What would you like to do with scheduled remote agents?";
+function formatSetupNotes(notes) {
+  const items = notes.map((n) => `- ${n}`).join(`
+`);
+  return `⚠ Heads-up:
+${items}`;
+}
+async function getCurrentRepoHttpsUrl() {
+  const remoteUrl = await getRemoteUrl();
+  if (!remoteUrl) {
+    return null;
+  }
+  const parsed = parseGitRemote(remoteUrl);
+  if (!parsed) {
+    return null;
+  }
+  return `https://${parsed.host}/${parsed.owner}/${parsed.name}`;
+}
+function buildPrompt(opts) {
+  const {
+    userTimezone,
+    connectorsInfo,
+    gitRepoUrl,
+    environmentsInfo,
+    createdEnvironment,
+    setupNotes,
+    needsGitHubAccessReminder,
+    userArgs
+  } = opts;
+  const setupNotesSection = userArgs && setupNotes.length > 0 ? `
+## Setup Notes
+
+${formatSetupNotes(setupNotes)}
+` : "";
+  const initialQuestion = setupNotes.length > 0 ? `${formatSetupNotes(setupNotes)}
+
+${BASE_QUESTION}` : BASE_QUESTION;
+  const firstStep = userArgs ? `The user has already told you what they want (see User Request at the bottom). Skip the initial question and go directly to the matching workflow.` : `Your FIRST action must be a single ${ASK_USER_QUESTION_TOOL_NAME} tool call (no preamble). Use this EXACT string for the \`question\` field — do not paraphrase or shorten it:
+
+${jsonStringify(initialQuestion)}
+
+Set \`header: "Action"\` and offer the four actions (create/list/update/run) as options. After the user picks, follow the matching workflow below.`;
+  return `# Schedule Remote Agents
+
+You are helping the user schedule, update, list, or run **remote** Claude Code agents. These are NOT local cron jobs — each trigger spawns a fully isolated remote session (CCR) in Anthropic's cloud infrastructure on a cron schedule. The agent runs in a sandboxed environment with its own git checkout, tools, and optional MCP connections.
+
+## First Step
+
+${firstStep}
+${setupNotesSection}
+
+## What You Can Do
+
+Use the \`${REMOTE_TRIGGER_TOOL_NAME}\` tool (load it first with \`ToolSearch select:${REMOTE_TRIGGER_TOOL_NAME}\`; auth is handled in-process — do not use curl):
+
+- \`{action: "list"}\` — list all triggers
+- \`{action: "get", trigger_id: "..."}\` — fetch one trigger
+- \`{action: "create", body: {...}}\` — create a trigger
+- \`{action: "update", trigger_id: "...", body: {...}}\` — partial update
+- \`{action: "run", trigger_id: "..."}\` — run a trigger now
+
+You CANNOT delete triggers. If the user asks to delete, direct them to: https://claude.ai/code/scheduled
+
+## Create body shape
+
+\`\`\`json
+{
+  "name": "AGENT_NAME",
+  "cron_expression": "CRON_EXPR",
+  "enabled": true,
+  "job_config": {
+    "ccr": {
+      "environment_id": "ENVIRONMENT_ID",
+      "session_context": {
+        "model": "claude-sonnet-4-6",
+        "sources": [
+          {"git_repository": {"url": "${gitRepoUrl || "https://github.com/ORG/REPO"}"}}
+        ],
+        "allowed_tools": ["Bash", "Read", "Write", "Edit", "Glob", "Grep"]
+      },
+      "events": [
+        {"data": {
+          "uuid": "<lowercase v4 uuid>",
+          "session_id": "",
+          "type": "user",
+          "parent_tool_use_id": null,
+          "message": {"content": "PROMPT_HERE", "role": "user"}
+        }}
+      ]
+    }
+  }
+}
+\`\`\`
+
+Generate a fresh lowercase UUID for \`events[].data.uuid\` yourself.
+
+## Available MCP Connectors
+
+These are the user's currently connected claude.ai MCP connectors:
+
+${connectorsInfo}
+
+When attaching connectors to a trigger, use the \`connector_uuid\` and \`name\` shown above (the name is already sanitized to only contain letters, numbers, hyphens, and underscores), and the connector's URL. The \`name\` field in \`mcp_connections\` must only contain \`[a-zA-Z0-9_-]\` — dots and spaces are NOT allowed.
+
+**Important:** Infer what services the agent needs from the user's description. For example, if they say "check Datadog and Slack me errors," the agent needs both Datadog and Slack connectors. Cross-reference against the list above and warn if any required service isn't connected. If a needed connector is missing, direct the user to https://claude.ai/settings/connectors to connect it first.
+
+## Environments
+
+Every trigger requires an \`environment_id\` in the job config. This determines where the remote agent runs. Ask the user which environment to use.
+
+${environmentsInfo}
+
+Use the \`id\` value as the \`environment_id\` in \`job_config.ccr.environment_id\`.
+${createdEnvironment ? `
+**Note:** A new environment \`${createdEnvironment.name}\` (id: \`${createdEnvironment.environment_id}\`) was just created for the user because they had none. Use this id for \`job_config.ccr.environment_id\` and mention the creation when you confirm the trigger config.
+` : ""}
+
+## API Field Reference
+
+### Create Trigger — Required Fields
+- \`name\` (string) — A descriptive name
+- \`cron_expression\` (string) — 5-field cron. **Minimum interval is 1 hour.**
+- \`job_config\` (object) — Session configuration (see structure above)
+
+### Create Trigger — Optional Fields
+- \`enabled\` (boolean, default: true)
+- \`mcp_connections\` (array) — MCP servers to attach:
+  \`\`\`json
+  [{"connector_uuid": "uuid", "name": "server-name", "url": "https://..."}]
+  \`\`\`
+
+### Update Trigger — Optional Fields
+All fields optional (partial update):
+- \`name\`, \`cron_expression\`, \`enabled\`, \`job_config\`
+- \`mcp_connections\` — Replace MCP connections
+- \`clear_mcp_connections\` (boolean) — Remove all MCP connections
+
+### Cron Expression Examples
+
+The user's local timezone is **${userTimezone}**. Cron expressions are always in UTC. When the user says a local time, convert it to UTC for the cron expression but confirm with them: "9am ${userTimezone} = Xam UTC, so the cron would be \`0 X * * 1-5\`."
+
+- \`0 9 * * 1-5\` — Every weekday at 9am **UTC**
+- \`0 */2 * * *\` — Every 2 hours
+- \`0 0 * * *\` — Daily at midnight **UTC**
+- \`30 14 * * 1\` — Every Monday at 2:30pm **UTC**
+- \`0 8 1 * *\` — First of every month at 8am **UTC**
+
+Minimum interval is 1 hour. \`*/30 * * * *\` will be rejected.
+
+## Workflow
+
+### CREATE a new trigger:
+
+1. **Understand the goal** — Ask what they want the remote agent to do. What repo(s)? What task? Remind them that the agent runs remotely — it won't have access to their local machine, local files, or local environment variables.
+2. **Craft the prompt** — Help them write an effective agent prompt. Good prompts are:
+   - Specific about what to do and what success looks like
+   - Clear about which files/areas to focus on
+   - Explicit about what actions to take (open PRs, commit, just analyze, etc.)
+3. **Set the schedule** — Ask when and how often. The user's timezone is ${userTimezone}. When they say a time (e.g., "every morning at 9am"), assume they mean their local time and convert to UTC for the cron expression. Always confirm the conversion: "9am ${userTimezone} = Xam UTC."
+4. **Choose the model** — Default to \`claude-sonnet-4-6\`. Tell the user which model you're defaulting to and ask if they want a different one.
+5. **Validate connections** — Infer what services the agent will need from the user's description. For example, if they say "check Datadog and Slack me errors," the agent needs both Datadog and Slack MCP connectors. Cross-reference with the connectors list above. If any are missing, warn the user and link them to https://claude.ai/settings/connectors to connect first.${gitRepoUrl ? ` The default git repo is already set to \`${gitRepoUrl}\`. Ask the user if this is the right repo or if they need a different one.` : " Ask which git repos the remote agent needs cloned into its environment."}
+6. **Review and confirm** — Show the full configuration before creating. Let them adjust.
+7. **Create it** — Call \`${REMOTE_TRIGGER_TOOL_NAME}\` with \`action: "create"\` and show the result. The response includes the trigger ID. Always output a link at the end: \`https://claude.ai/code/scheduled/{TRIGGER_ID}\`
+
+### UPDATE a trigger:
+
+1. List triggers first so they can pick one
+2. Ask what they want to change
+3. Show current vs proposed value
+4. Confirm and update
+
+### LIST triggers:
+
+1. Fetch and display in a readable format
+2. Show: name, schedule (human-readable), enabled/disabled, next run, repo(s)
+
+### RUN NOW:
+
+1. List triggers if they haven't specified which one
+2. Confirm which trigger
+3. Execute and confirm
+
+## Important Notes
+
+- These are REMOTE agents — they run in Anthropic's cloud, not on the user's machine. They cannot access local files, local services, or local environment variables.
+- Always convert cron to human-readable when displaying
+- Default to \`enabled: true\` unless user says otherwise
+- Accept GitHub URLs in any format (https://github.com/org/repo, org/repo, etc.) and normalize to the full HTTPS URL (without .git suffix)
+- The prompt is the most important part — spend time getting it right. The remote agent starts with zero context, so the prompt must be self-contained.
+- To delete a trigger, direct users to https://claude.ai/code/scheduled
+${needsGitHubAccessReminder ? `- If the user's request seems to require GitHub repo access (e.g. cloning a repo, opening PRs, reading code), remind them that ${getFeatureValue_CACHED_MAY_BE_STALE("tengu_cobalt_lantern", false) ? "they should run /web-setup to connect their GitHub account (or install the Claude GitHub App on the repo as an alternative) — otherwise the remote agent won't be able to access it" : "they need the Claude GitHub App installed on the repo — otherwise the remote agent won't be able to access it"}.` : ""}
+${userArgs ? `
+## User Request
+
+The user said: "${userArgs}"
+
+Start by understanding their intent and working through the appropriate workflow above.` : ""}`;
+}
+export function registerScheduleRemoteAgentsSkill() {
+  registerBundledSkill({
+    name: "schedule",
+    description: "Create, update, list, or run scheduled remote agents (triggers) that execute on a cron schedule.",
+    whenToUse: "When the user wants to schedule a recurring remote agent, set up automated tasks, create a cron job for Claude Code, or manage their scheduled agents/triggers.",
+    userInvocable: true,
+    isEnabled: () => getFeatureValue_CACHED_MAY_BE_STALE("tengu_surreal_dali", false) && isPolicyAllowed("allow_remote_sessions"),
+    allowedTools: [REMOTE_TRIGGER_TOOL_NAME, ASK_USER_QUESTION_TOOL_NAME],
+    async getPromptForCommand(args, context) {
+      if (!getClaudeAIOAuthTokens()?.accessToken) {
+        return [
+          {
+            type: "text",
+            text: "You need to authenticate with a claude.ai account first. API accounts are not supported. Run /login, then try /schedule again."
+          }
+        ];
+      }
+      let environments;
+      try {
+        environments = await fetchEnvironments();
+      } catch (err) {
+        logForDebugging(`[schedule] Failed to fetch environments: ${err}`, {
+          level: "warn"
+        });
+        return [
+          {
+            type: "text",
+            text: "We're having trouble connecting with your remote claude.ai account to set up a scheduled task. Please try /schedule again in a few minutes."
+          }
+        ];
+      }
+      let createdEnvironment = null;
+      if (environments.length === 0) {
+        try {
+          createdEnvironment = await createDefaultCloudEnvironment("claude-code-default");
+          environments = [createdEnvironment];
+        } catch (err) {
+          logForDebugging(`[schedule] Failed to create environment: ${err}`, {
+            level: "warn"
+          });
+          return [
+            {
+              type: "text",
+              text: "No remote environments found, and we could not create one automatically. Visit https://claude.ai/code to set one up, then run /schedule again."
+            }
+          ];
+        }
+      }
+      const setupNotes = [];
+      let needsGitHubAccessReminder = false;
+      const repo = await detectCurrentRepositoryWithHost();
+      if (repo === null) {
+        setupNotes.push(`Not in a git repo — you'll need to specify a repo URL manually (or skip repos entirely).`);
+      } else if (repo.host === "github.com") {
+        const { hasAccess } = await checkRepoForRemoteAccess(repo.owner, repo.name);
+        if (!hasAccess) {
+          needsGitHubAccessReminder = true;
+          const webSetupEnabled = getFeatureValue_CACHED_MAY_BE_STALE("tengu_cobalt_lantern", false);
+          const msg = webSetupEnabled ? `GitHub not connected for ${repo.owner}/${repo.name} — run /web-setup to sync your GitHub credentials, or install the Claude GitHub App at https://claude.ai/code/onboarding?magic=github-app-setup.` : `Claude GitHub App not installed on ${repo.owner}/${repo.name} — install at https://claude.ai/code/onboarding?magic=github-app-setup if your trigger needs this repo.`;
+          setupNotes.push(msg);
+        }
+      }
+      const connectors = getConnectedClaudeAIConnectors(context.options.mcpClients);
+      if (connectors.length === 0) {
+        setupNotes.push(`No MCP connectors — connect at https://claude.ai/settings/connectors if needed.`);
+      }
+      const userTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+      const connectorsInfo = formatConnectorsInfo(connectors);
+      const gitRepoUrl = await getCurrentRepoHttpsUrl();
+      const lines = ["Available environments:"];
+      for (const env of environments) {
+        lines.push(`- ${env.name} (id: ${env.environment_id}, kind: ${env.kind})`);
+      }
+      const environmentsInfo = lines.join(`
+`);
+      const prompt = buildPrompt({
+        userTimezone,
+        connectorsInfo,
+        gitRepoUrl,
+        environmentsInfo,
+        createdEnvironment,
+        setupNotes,
+        needsGitHubAccessReminder,
+        userArgs: args
+      });
+      return [{ type: "text", text: prompt }];
+    }
+  });
+}

package/dist/src/skills/bundled/simplify.js

@@ -0,0 +1,70 @@
+import { AGENT_TOOL_NAME } from "../../tools/AgentTool/constants.js";
+import { registerBundledSkill } from "../bundledSkills.js";
+const SIMPLIFY_PROMPT = `# Simplify: Code Review and Cleanup
+
+Review all changed files for reuse, quality, and efficiency. Fix any issues found.
+
+## Phase 1: Identify Changes
+
+Run \`git diff\` (or \`git diff HEAD\` if there are staged changes) to see what changed. If there are no git changes, review the most recently modified files that the user mentioned or that you edited earlier in this conversation.
+
+## Phase 2: Launch Three Review Agents in Parallel
+
+Use the ${AGENT_TOOL_NAME} tool to launch all three agents concurrently in a single message. Pass each agent the full diff so it has the complete context.
+
+### Agent 1: Code Reuse Review
+
+For each change:
+
+1. **Search for existing utilities and helpers** that could replace newly written code. Look for similar patterns elsewhere in the codebase — common locations are utility directories, shared modules, and files adjacent to the changed ones.
+2. **Flag any new function that duplicates existing functionality.** Suggest the existing function to use instead.
+3. **Flag any inline logic that could use an existing utility** — hand-rolled string manipulation, manual path handling, custom environment checks, ad-hoc type guards, and similar patterns are common candidates.
+
+### Agent 2: Code Quality Review
+
+Review the same changes for hacky patterns:
+
+1. **Redundant state**: state that duplicates existing state, cached values that could be derived, observers/effects that could be direct calls
+2. **Parameter sprawl**: adding new parameters to a function instead of generalizing or restructuring existing ones
+3. **Copy-paste with slight variation**: near-duplicate code blocks that should be unified with a shared abstraction
+4. **Leaky abstractions**: exposing internal details that should be encapsulated, or breaking existing abstraction boundaries
+5. **Stringly-typed code**: using raw strings where constants, enums (string unions), or branded types already exist in the codebase
+6. **Unnecessary JSX nesting**: wrapper Boxes/elements that add no layout value — check if inner component props (flexShrink, alignItems, etc.) already provide the needed behavior
+7. **Unnecessary comments**: comments explaining WHAT the code does (well-named identifiers already do that), narrating the change, or referencing the task/caller — delete; keep only non-obvious WHY (hidden constraints, subtle invariants, workarounds)
+
+### Agent 3: Efficiency Review
+
+Review the same changes for efficiency:
+
+1. **Unnecessary work**: redundant computations, repeated file reads, duplicate network/API calls, N+1 patterns
+2. **Missed concurrency**: independent operations run sequentially when they could run in parallel
+3. **Hot-path bloat**: new blocking work added to startup or per-request/per-render hot paths
+4. **Recurring no-op updates**: state/store updates inside polling loops, intervals, or event handlers that fire unconditionally — add a change-detection guard so downstream consumers aren't notified when nothing changed. Also: if a wrapper function takes an updater/reducer callback, verify it honors same-reference returns (or whatever the "no change" signal is) — otherwise callers' early-return no-ops are silently defeated
+5. **Unnecessary existence checks**: pre-checking file/resource existence before operating (TOCTOU anti-pattern) — operate directly and handle the error
+6. **Memory**: unbounded data structures, missing cleanup, event listener leaks
+7. **Overly broad operations**: reading entire files when only a portion is needed, loading all items when filtering for one
+
+## Phase 3: Fix Issues
+
+Wait for all three agents to complete. Aggregate their findings and fix each issue directly. If a finding is a false positive or not worth addressing, note it and move on — do not argue with the finding, just skip it.
+
+When done, briefly summarize what was fixed (or confirm the code was already clean).
+`;
+export function registerSimplifySkill() {
+  registerBundledSkill({
+    name: "simplify",
+    description: "Review changed code for reuse, quality, and efficiency, then fix any issues found.",
+    userInvocable: true,
+    async getPromptForCommand(args) {
+      let prompt = SIMPLIFY_PROMPT;
+      if (args) {
+        prompt += `
+
+## Additional Focus
+
+${args}`;
+      }
+      return [{ type: "text", text: prompt }];
+    }
+  });
+}

package/dist/src/skills/bundled/skillify.js

@@ -0,0 +1,179 @@
+import { getSessionMemoryContent } from "../../services/SessionMemory/sessionMemoryUtils.js";
+import { getMessagesAfterCompactBoundary } from "../../utils/messages.js";
+import { registerBundledSkill } from "../bundledSkills.js";
+function extractUserMessages(messages) {
+  return messages.filter((m) => m.type === "user").map((m) => {
+    const content = m.message.content;
+    if (typeof content === "string")
+      return content;
+    return content.filter((b) => b.type === "text").map((b) => b.text).join(`
+`);
+  }).filter((text) => text.trim().length > 0);
+}
+const SKILLIFY_PROMPT = `# Skillify {{userDescriptionBlock}}
+
+You are capturing this session's repeatable process as a reusable skill.
+
+## Your Session Context
+
+Here is the session memory summary:
+<session_memory>
+{{sessionMemory}}
+</session_memory>
+
+Here are the user's messages during this session. Pay attention to how they steered the process, to help capture their detailed preferences in the skill:
+<user_messages>
+{{userMessages}}
+</user_messages>
+
+## Your Task
+
+### Step 1: Analyze the Session
+
+Before asking any questions, analyze the session to identify:
+- What repeatable process was performed
+- What the inputs/parameters were
+- The distinct steps (in order)
+- The success artifacts/criteria (e.g. not just "writing code," but "an open PR with CI fully passing") for each step
+- Where the user corrected or steered you
+- What tools and permissions were needed
+- What agents were used
+- What the goals and success artifacts were
+
+### Step 2: Interview the User
+
+You will use the AskUserQuestion to understand what the user wants to automate. Important notes:
+- Use AskUserQuestion for ALL questions! Never ask questions via plain text.
+- For each round, iterate as much as needed until the user is happy.
+- The user always has a freeform "Other" option to type edits or feedback -- do NOT add your own "Needs tweaking" or "I'll provide edits" option. Just offer the substantive choices.
+
+**Round 1: High level confirmation**
+- Suggest a name and description for the skill based on your analysis. Ask the user to confirm or rename.
+- Suggest high-level goal(s) and specific success criteria for the skill.
+
+**Round 2: More details**
+- Present the high-level steps you identified as a numbered list. Tell the user you will dig into the detail in the next round.
+- If you think the skill will require arguments, suggest arguments based on what you observed. Make sure you understand what someone would need to provide.
+- If it's not clear, ask if this skill should run inline (in the current conversation) or forked (as a sub-agent with its own context). Forked is better for self-contained tasks that don't need mid-process user input; inline is better when the user wants to steer mid-process.
+- Ask where the skill should be saved. Suggest a default based on context (repo-specific workflows → repo, cross-repo personal workflows → user). Options:
+  - **This repo** (\`.claude/skills/<name>/SKILL.md\`) — for workflows specific to this project
+  - **Personal** (\`~/.claude/skills/<name>/SKILL.md\`) — follows you across all repos
+
+**Round 3: Breaking down each step**
+For each major step, if it's not glaringly obvious, ask:
+- What does this step produce that later steps need? (data, artifacts, IDs)
+- What proves that this step succeeded, and that we can move on?
+- Should the user be asked to confirm before proceeding? (especially for irreversible actions like merging, sending messages, or destructive operations)
+- Are any steps independent and could run in parallel? (e.g., posting to Slack and monitoring CI at the same time)
+- How should the skill be executed? (e.g. always use a Task agent to conduct code review, or invoke an agent team for a set of concurrent steps)
+- What are the hard constraints or hard preferences? Things that must or must not happen?
+
+You may do multiple rounds of AskUserQuestion here, one round per step, especially if there are more than 3 steps or many clarification questions. Iterate as much as needed.
+
+IMPORTANT: Pay special attention to places where the user corrected you during the session, to help inform your design.
+
+**Round 4: Final questions**
+- Confirm when this skill should be invoked, and suggest/confirm trigger phrases too. (e.g. For a cherrypick workflow you could say: Use when the user wants to cherry-pick a PR to a release branch. Examples: 'cherry-pick to release', 'CP this PR', 'hotfix.')
+- You can also ask for any other gotchas or things to watch out for, if it's still unclear.
+
+Stop interviewing once you have enough information. IMPORTANT: Don't over-ask for simple processes!
+
+### Step 3: Write the SKILL.md
+
+Create the skill directory and file at the location the user chose in Round 2.
+
+Use this format:
+
+\`\`\`markdown
+---
+name: {{skill-name}}
+description: {{one-line description}}
+allowed-tools:
+  {{list of tool permission patterns observed during session}}
+when_to_use: {{detailed description of when Claude should automatically invoke this skill, including trigger phrases and example user messages}}
+argument-hint: "{{hint showing argument placeholders}}"
+arguments:
+  {{list of argument names}}
+context: {{inline or fork -- omit for inline}}
+---
+
+# {{Skill Title}}
+Description of skill
+
+## Inputs
+- \`$arg_name\`: Description of this input
+
+## Goal
+Clearly stated goal for this workflow. Best if you have clearly defined artifacts or criteria for completion.
+
+## Steps
+
+### 1. Step Name
+What to do in this step. Be specific and actionable. Include commands when appropriate.
+
+**Success criteria**: ALWAYS include this! This shows that the step is done and we can move on. Can be a list.
+
+IMPORTANT: see the next section below for the per-step annotations you can optionally include for each step.
+
+...
+\`\`\`
+
+**Per-step annotations**:
+- **Success criteria** is REQUIRED on every step. This helps the model understand what the user expects from their workflow, and when it should have the confidence to move on.
+- **Execution**: \`Direct\` (default), \`Task agent\` (straightforward subagents), \`Teammate\` (agent with true parallelism and inter-agent communication), or \`[human]\` (user does it). Only needs specifying if not Direct.
+- **Artifacts**: Data this step produces that later steps need (e.g., PR number, commit SHA). Only include if later steps depend on it.
+- **Human checkpoint**: When to pause and ask the user before proceeding. Include for irreversible actions (merging, sending messages), error judgment (merge conflicts), or output review.
+- **Rules**: Hard rules for the workflow. User corrections during the reference session can be especially useful here.
+
+**Step structure tips:**
+- Steps that can run concurrently use sub-numbers: 3a, 3b
+- Steps requiring the user to act get \`[human]\` in the title
+- Keep simple skills simple -- a 2-step skill doesn't need annotations on every step
+
+**Frontmatter rules:**
+- \`allowed-tools\`: Minimum permissions needed (use patterns like \`Bash(gh:*)\` not \`Bash\`)
+- \`context\`: Only set \`context: fork\` for self-contained skills that don't need mid-process user input.
+- \`when_to_use\` is CRITICAL -- tells the model when to auto-invoke. Start with "Use when..." and include trigger phrases. Example: "Use when the user wants to cherry-pick a PR to a release branch. Examples: 'cherry-pick to release', 'CP this PR', 'hotfix'."
+- \`arguments\` and \`argument-hint\`: Only include if the skill takes parameters. Use \`$name\` in the body for substitution.
+
+### Step 4: Confirm and Save
+
+Before writing the file, output the complete SKILL.md content as a yaml code block in your response so the user can review it with proper syntax highlighting. Then ask for confirmation using AskUserQuestion with a simple question like "Does this SKILL.md look good to save?" — do NOT use the body field, keep the question concise.
+
+After writing, tell the user:
+- Where the skill was saved
+- How to invoke it: \`/{{skill-name}} [arguments]\`
+- That they can edit the SKILL.md directly to refine it
+`;
+export function registerSkillifySkill() {
+  if (process.env.USER_TYPE !== "ant") {
+    return;
+  }
+  registerBundledSkill({
+    name: "skillify",
+    description: "Capture this session's repeatable process into a skill. Call at end of the process you want to capture with an optional description.",
+    allowedTools: [
+      "Read",
+      "Write",
+      "Edit",
+      "Glob",
+      "Grep",
+      "AskUserQuestion",
+      "Bash(mkdir:*)"
+    ],
+    userInvocable: true,
+    disableModelInvocation: true,
+    argumentHint: "[description of the process you want to capture]",
+    async getPromptForCommand(args, context) {
+      const sessionMemory = await getSessionMemoryContent() ?? "No session memory available.";
+      const userMessages = extractUserMessages(getMessagesAfterCompactBoundary(context.messages));
+      const userDescriptionBlock = args ? `The user described this process as: "${args}"` : "";
+      const prompt = SKILLIFY_PROMPT.replace("{{sessionMemory}}", sessionMemory).replace("{{userMessages}}", userMessages.join(`
+
+---
+
+`)).replace("{{userDescriptionBlock}}", userDescriptionBlock);
+      return [{ type: "text", text: prompt }];
+    }
+  });
+}