thaddeus 1.0.18 → 1.0.27

package/src/skills/bundled/remember.js

@@ -0,0 +1,73 @@
+import { isAutoMemoryEnabled } from '../../memdir/paths.js';
+import { registerBundledSkill } from '../bundledSkills.js';
+export function registerRememberSkill() {
+    // Thaddeus fork: USER_TYPE gate removed April 2, 2026
+    const SKILL_PROMPT = `# Memory Review
+
+## Goal
+Review the user's memory landscape and produce a clear report of proposed changes, grouped by action type. Do NOT apply changes — present proposals for user approval.
+
+## Steps
+
+### 1. Gather all memory layers
+Read THADDEUS.md and THADDEUS.local.md from the project root (if they exist). Your auto-memory content is already in your system prompt — review it there. Note which team memory sections exist, if any.
+
+**Success criteria**: You have the contents of all memory layers and can compare them.
+
+### 2. Classify each auto-memory entry
+For each substantive entry in auto-memory, determine the best destination:
+
+| Destination | What belongs there | Examples |
+|---|---|---|
+| **THADDEUS.md** | Project conventions and instructions for Thaddeus that all contributors should follow | "use bun not npm", "API routes use kebab-case", "test command is bun test", "prefer functional style" |
+| **THADDEUS.local.md** | Personal instructions for Thaddeus specific to this user, not applicable to other contributors | "I prefer concise responses", "always explain trade-offs", "don't auto-commit", "run tests before committing" |
+| **Team memory** | Org-wide knowledge that applies across repositories (only if team memory is configured) | "deploy PRs go through #deploy-queue", "staging is at staging.internal", "platform team owns infra" |
+| **Stay in auto-memory** | Working notes, temporary context, or entries that don't clearly fit elsewhere | Session-specific observations, uncertain patterns |
+
+**Important distinctions:**
+- THADDEUS.md and THADDEUS.local.md contain instructions for Thaddeus, not user preferences for external tools (editor theme, IDE keybindings, etc. don't belong in either)
+- Workflow practices (PR conventions, merge strategies, branch naming) are ambiguous — ask the user whether they're personal or team-wide
+- When unsure, ask rather than guess
+
+**Success criteria**: Each entry has a proposed destination or is flagged as ambiguous.
+
+### 3. Identify cleanup opportunities
+Scan across all layers for:
+- **Duplicates**: Auto-memory entries already captured in THADDEUS.md or THADDEUS.local.md → propose removing from auto-memory
+- **Outdated**: THADDEUS.md or THADDEUS.local.md entries contradicted by newer auto-memory entries → propose updating the older layer
+- **Conflicts**: Contradictions between any two layers → propose resolution, noting which is more recent
+
+**Success criteria**: All cross-layer issues identified.
+
+### 4. Present the report
+Output a structured report grouped by action type:
+1. **Promotions** — entries to move, with destination and rationale
+2. **Cleanup** — duplicates, outdated entries, conflicts to resolve
+3. **Ambiguous** — entries where you need the user's input on destination
+4. **No action needed** — brief note on entries that should stay put
+
+If auto-memory is empty, say so and offer to review THADDEUS.md for cleanup.
+
+**Success criteria**: User can review and approve/reject each proposal individually.
+
+## Rules
+- Present ALL proposals before making any changes
+- Do NOT modify files without explicit user approval
+- Do NOT create new files unless the target doesn't exist yet
+- Ask about ambiguous entries — don't guess
+`;
+    registerBundledSkill({
+        name: 'remember',
+        description: 'Review auto-memory entries and propose promotions to THADDEUS.md, THADDEUS.local.md, or shared memory. Also detects outdated, conflicting, and duplicate entries across memory layers.',
+        whenToUse: 'Use when the user wants to review, organize, or promote their auto-memory entries. Also useful for cleaning up outdated or conflicting entries across THADDEUS.md, THADDEUS.local.md, and auto-memory.',
+        userInvocable: true,
+        isEnabled: () => isAutoMemoryEnabled(),
+        async getPromptForCommand(args) {
+            let prompt = SKILL_PROMPT;
+            if (args) {
+                prompt += `\n## Additional context from user\n\n${args}`;
+            }
+            return [{ type: 'text', text: prompt }];
+        },
+    });
+}

package/src/skills/bundled/runSkillGenerator.js

@@ -0,0 +1,12 @@
+// Stub — run skill generator (RUN_SKILL_GENERATOR feature)
+import { registerBundledSkill } from '../bundledSkills.js';
+export function registerRunSkillGeneratorSkill() {
+    registerBundledSkill({
+        name: 'run-skill-generator',
+        description: 'Skill generator (not available in this fork)',
+        isEnabled: () => false,
+        async getPromptForCommand() {
+            return [{ type: 'text', text: 'Skill generator is not available in this fork.' }];
+        },
+    });
+}

package/src/skills/bundled/scheduleRemoteAgents.js

@@ -0,0 +1,373 @@
+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';
+// Base58 alphabet (Bitcoin-style) used by the tagged ID system
+const BASE58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+/**
+ * Decode a mcpsrv_ tagged ID to a UUID string.
+ * Tagged IDs have format: mcpsrv_01{base58(uuid.int)}
+ * where 01 is the version prefix.
+ *
+ * TODO(public-ship): Before shipping publicly, the /v1/mcp_servers endpoint
+ * should return the raw UUID directly so we don't need this client-side decoding.
+ * The tagged ID format is an internal implementation detail that could change.
+ */
+function taggedIdToUUID(taggedId) {
+    const prefix = 'mcpsrv_';
+    if (!taggedId.startsWith(prefix)) {
+        return null;
+    }
+    const rest = taggedId.slice(prefix.length);
+    // Skip version prefix (2 chars, always "01")
+    const base58Data = rest.slice(2);
+    // Decode base58 to bigint
+    let n = 0n;
+    for (const c of base58Data) {
+        const idx = BASE58.indexOf(c);
+        if (idx === -1) {
+            return null;
+        }
+        n = n * 58n + BigInt(idx);
+    }
+    // Convert to UUID hex string
+    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://the-oracleai.com/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('\n');
+}
+const BASE_QUESTION = 'What would you like to do with scheduled remote agents?';
+/**
+ * Formats setup notes as a bulleted Heads-up block. Shared between the
+ * initial AskUserQuestion dialog text (no-args path) and the prompt-body
+ * section (args path) so notes are never silently dropped.
+ */
+function formatSetupNotes(notes) {
+    const items = notes.map(n => `- ${n}`).join('\n');
+    return `⚠ Heads-up:\n${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;
+    // When the user passes args, the initial AskUserQuestion dialog is skipped.
+    // Setup notes must surface in the prompt body instead, otherwise they're
+    // computed and silently discarded (regression vs. the old hard-block).
+    const setupNotesSection = userArgs && setupNotes.length > 0
+        ? `\n## Setup Notes\n\n${formatSetupNotes(setupNotes)}\n`
+        : '';
+    const initialQuestion = setupNotes.length > 0
+        ? `${formatSetupNotes(setupNotes)}\n\n${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** Thaddeus agents. These are NOT local cron jobs — each trigger spawns a fully isolated remote session (CCR) in Delphi Labs' 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://the-oracleai.com/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 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://the-oracleai.com/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 ? `\n**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.\n` : ''}
+
+## 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://the-oracleai.com/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** \u2014 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://the-oracleai.com/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 Delphi Labs' 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://the-oracleai.com/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('thaddeus_cobalt_lantern', false) ? "they should run /web-setup to connect their GitHub account (or install the Thaddeus GitHub App on the repo as an alternative) — otherwise the remote agent won't be able to access it" : "they need the Thaddeus GitHub App installed on the repo — otherwise the remote agent won't be able to access it"}.` : ''}
+${userArgs ? `\n## User Request\n\nThe user said: "${userArgs}"\n\nStart 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 Thaddeus, or manage their scheduled agents/triggers.',
+        userInvocable: true,
+        isEnabled: () => getFeatureValue_CACHED_MAY_BE_STALE('thaddeus_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 Thaddeus 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 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('thaddeus-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://the-oracleai.com/code to set one up, then run /schedule again.',
+                        },
+                    ];
+                }
+            }
+            // Soft setup checks — collected as upfront notes embedded in the initial
+            // AskUserQuestion dialog. Never block — triggers don't require a git
+            // source (e.g., Slack-only polls), and the trigger's sources may point
+            // at a different repo than cwd anyway.
+            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('thaddeus_cobalt_lantern', false);
+                    const msg = webSetupEnabled
+                        ? `GitHub not connected for ${repo.owner}/${repo.name} \u2014 run /web-setup to sync your GitHub credentials, or install the Thaddeus GitHub App at https://the-oracleai.com/code/onboarding?magic=github-app-setup.`
+                        : `Thaddeus GitHub App not installed on ${repo.owner}/${repo.name} \u2014 install at https://the-oracleai.com/code/onboarding?magic=github-app-setup if your trigger needs this repo.`;
+                    setupNotes.push(msg);
+                }
+            }
+            // Non-github.com hosts (GHE/GitLab/etc.): silently skip. The GitHub
+            // App check is github.com-specific, and the "not in a git repo" note
+            // would be factually wrong — getCurrentRepoHttpsUrl() below will
+            // still populate gitRepoUrl with the GHE URL.
+            const connectors = getConnectedClaudeAIConnectors(context.options.mcpClients);
+            if (connectors.length === 0) {
+                setupNotes.push(`No MCP connectors — connect at https://the-oracleai.com/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('\n');
+            const prompt = buildPrompt({
+                userTimezone,
+                connectorsInfo,
+                gitRepoUrl,
+                environmentsInfo,
+                createdEnvironment,
+                setupNotes,
+                needsGitHubAccessReminder,
+                userArgs: args,
+            });
+            return [{ type: 'text', text: prompt }];
+        },
+    });
+}

package/src/skills/bundled/simplify.js

@@ -0,0 +1,66 @@
+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 += `\n\n## Additional Focus\n\n${args}`;
+            }
+            return [{ type: 'text', text: prompt }];
+        },
+    });
+}