claude-code-extensions 0.1.0

package/patches/always-show-context.js

@@ -0,0 +1,123 @@
+/**
+ * Always Show Context
+ *
+ * Shows context usage percentage at all times, not just when approaching
+ * the limit. The built-in TokenWarning only fires within 20k tokens of
+ * the threshold — on a 1M context window, that's ~98% full, far too late.
+ *
+ * Addresses: https://github.com/anthropics/claude-code/issues/18456 (51 👍)
+ *
+ * Strategy:
+ * 1. Find TokenWarning by its unique "Context low" string
+ * 2. Remove the isAboveWarningThreshold gate so the indicator always renders
+ * 3. Fix the warning color to be neutral when below threshold
+ * 4. Soften "Context low" label to "Context" for always-on display
+ *
+ * For auto-compact users (the default): shows a dim "X% context used"
+ * line at all times. For manual-compact users: shows "Context (X% remaining)"
+ * in neutral color when below threshold, escalating to warning/error colors
+ * as context fills up.
+ */
+
+export default {
+  id: 'always-show-context',
+  name: 'Always Show Context',
+  description: 'Always display context usage percentage, not just when near limit',
+
+  apply(ctx) {
+    const { ast, editor, find, index, assert, src } = ctx;
+    const { findFirst } = find;
+
+    // Find TokenWarning function via its unique "Context low" marker.
+    // Check indexed literals first (string concat), then template elements.
+    let marker = null;
+    for (const [value, nodes] of index.literalsByValue) {
+      if (typeof value === 'string' && value.includes('Context low')) {
+        marker = nodes[0];
+        break;
+      }
+    }
+    if (!marker) {
+      marker = findFirst(ast, n =>
+        n.type === 'TemplateElement' &&
+        n.value?.raw?.includes('Context low')
+      );
+    }
+    assert(marker, 'Could not find "Context low" marker in bundle');
+
+    const fn = index.enclosingFunction(marker);
+    assert(fn, 'Could not find TokenWarning function');
+
+    // Find the early-return gate:
+    //   if (!isAboveWarningThreshold || suppressWarning) { return null; }
+    // Pattern: IfStatement → test: !X || Y, consequent: return null,
+    // and it must appear before the "Context low" string.
+    const gate = findFirst(fn, n => {
+      if (n.type !== 'IfStatement' || n.start >= marker.start) return false;
+      const t = n.test;
+      if (t.type !== 'LogicalExpression' || t.operator !== '||') return false;
+      if (t.left.type !== 'UnaryExpression' || t.left.operator !== '!') return false;
+      return findFirst(n.consequent, r =>
+        r.type === 'ReturnStatement' &&
+        r.argument?.type === 'Literal' &&
+        r.argument.value === null
+      ) !== null;
+    });
+    assert(gate, 'Could not find early-return gate: if(!X||Y){return null}');
+
+    // Save the minified name for isAboveWarningThreshold before editing
+    const warnVar = gate.test.left.argument;
+    assert(warnVar.type === 'Identifier',
+      'Expected Identifier for isAboveWarningThreshold');
+
+    // Edit 1: Remove threshold check from gate, keep suppress check.
+    // !isAboveWarningThreshold || suppressWarning → suppressWarning
+    editor.replaceRange(gate.test.start, gate.test.end, src(gate.test.right));
+
+    // Edit 2: Neutral color when below warning threshold.
+    // Find: isAboveErrorThreshold ? "error" : "warning"
+    // Replace "warning" with: isAboveWarningThreshold ? "warning" : void 0
+    // This makes text render in default color when context usage is low.
+    const colorTernary = findFirst(fn, n =>
+      n.type === 'ConditionalExpression' &&
+      n.consequent.type === 'Literal' && n.consequent.value === 'error' &&
+      n.alternate.type === 'Literal' && n.alternate.value === 'warning'
+    );
+    if (colorTernary) {
+      editor.replaceRange(
+        colorTernary.alternate.start,
+        colorTernary.alternate.end,
+        `${warnVar.name}?"warning":void 0`
+      );
+    }
+
+    // Edit 3: Soften "Context low" → "Context" for neutral always-on display.
+    const fnSrc = src(fn);
+    const needle = 'Context low';
+    let pos = 0;
+    while ((pos = fnSrc.indexOf(needle, pos)) !== -1) {
+      editor.replaceRange(
+        fn.start + pos,
+        fn.start + pos + needle.length,
+        'Context'
+      );
+      pos += needle.length;
+    }
+
+    // Edit 4: Change "X% until auto-compact" → "X% context used"
+    // The bundle has: reactiveOnlyMode ? `${100-var}% context used` : `${var}% until auto-compact`
+    // reactiveOnlyMode is always false, so patch the alternate branch to also show context used.
+    const autocompactTpl = findFirst(fn, n =>
+      n.type === 'TemplateLiteral' &&
+      n.quasis.some(q => q.value?.raw?.includes('% until auto-compact'))
+    );
+    if (autocompactTpl) {
+      const varName = src(autocompactTpl.expressions[0]);
+      editor.replaceRange(
+        autocompactTpl.start,
+        autocompactTpl.end,
+        `\`\${100-${varName}}% context used\``
+      );
+    }
+  },
+};

package/patches/always-show-thinking.js

@@ -0,0 +1,65 @@
+/**
+ * Always Show Thinking Patch
+ *
+ * Makes Claude's thinking blocks always display expanded instead of
+ * collapsed behind "∴ Thinking (ctrl+o to expand)".
+ *
+ * Addresses: https://github.com/anthropics/claude-code/issues/8477 (195 👍)
+ *
+ * In AssistantThinkingMessage, the gate is:
+ *   const shouldShowFullThinking = isTranscriptMode || verbose;
+ *   if (!shouldShowFullThinking) { return <collapsed view> }
+ *
+ * We find the function by its unique "∴ Thinking" string and replace
+ * the negated OR gate with `false` so the expanded view always renders.
+ */
+
+export default {
+  id: 'always-show-thinking',
+  name: 'Always Show Thinking',
+  description: 'Show thinking block content inline instead of collapsed',
+
+  apply(ctx) {
+    const { ast, editor, find, index, assert, src } = ctx;
+    const { findFirst } = find;
+
+    // Find the AssistantThinkingMessage function by its unique string literal.
+    // The "∴" character (U+2234, "therefore") only appears in this component.
+    // Use the literal index to find the marker, then walk up to its enclosing function.
+    let thinkingMarker = null;
+    for (const [value, nodes] of index.literalsByValue) {
+      if (typeof value === 'string' && value.includes('\u2234 Thinking')) {
+        thinkingMarker = nodes[0];
+        break;
+      }
+    }
+    assert(thinkingMarker, 'Could not find "∴ Thinking" literal');
+    const thinkingFn = index.enclosingFunction(thinkingMarker);
+    assert(thinkingFn, 'Could not find AssistantThinkingMessage function (marker: "∴ Thinking")');
+
+    // Find the gate: if(!(Y||O)) where Y=isTranscriptMode, O=verbose.
+    // Structure: IfStatement whose test is UnaryExpression(!) wrapping LogicalExpression(||)
+    // This is the FIRST such pattern in the function, appearing before the "∴ Thinking" strings.
+    const gate = findFirst(thinkingFn, n =>
+      n.type === 'IfStatement'
+      && n.test.type === 'UnaryExpression'
+      && n.test.operator === '!'
+      && n.test.argument.type === 'LogicalExpression'
+      && n.test.argument.operator === '||'
+    );
+    assert(gate, 'Could not find thinking display gate: if(!(X||Y))');
+
+    // Verify this is the right gate by checking it appears before the "∴ Thinking" string
+    const firstThinkingLiteral = findFirst(thinkingFn, n =>
+      n.type === 'Literal' && typeof n.value === 'string'
+      && n.value.includes('\u2234 Thinking'));
+    assert(
+      gate.start < firstThinkingLiteral.start,
+      'Gate should appear before "∴ Thinking" literal'
+    );
+
+    // Replace the test expression with `false` so the collapsed branch is never taken.
+    // This makes thinking always display in expanded mode.
+    editor.replaceRange(gate.test.start, gate.test.end, 'false');
+  },
+};

package/patches/banner.js

@@ -0,0 +1,58 @@
+/**
+ * Attribution Banner Patch
+ *
+ * Changes "Claude Code" to "Claude Code · @wormcoffee" on the title line.
+ * Targets the bold <Text> in the condensed layout and the border title
+ * in the boxed layout. No extra elements, no layout changes.
+ */
+
+export default {
+  id: 'banner',
+  name: 'Attribution Banner',
+  description: 'Show "@wormcoffee" on the Claude Code title line',
+
+  apply(ctx) {
+    const { ast, editor, find, index, src, assert } = ctx;
+    const { findFirst } = find;
+
+    // ── Condensed layout: createElement(T, {bold:true}, "Claude Code") ──
+    // Use literal index to find "Claude Code", then walk up to the createElement call.
+
+    const claudeCodeLiterals = index.literalsByValue.get('Claude Code') || [];
+    let boldTextCall = null;
+    for (const lit of claudeCodeLiterals) {
+      const call = index.ancestor(lit, 'CallExpression');
+      if (!call || call.callee.type !== 'MemberExpression' || call.callee.property.name !== 'createElement') continue;
+      const hasBold = call.arguments.some(a =>
+        a?.type === 'ObjectExpression' &&
+        a.properties.some(p => p.key?.type === 'Identifier' && p.key.name === 'bold'));
+      if (hasBold) { boldTextCall = call; break; }
+    }
+    assert(boldTextCall, 'Could not find createElement(T, {bold}, "Claude Code")');
+
+    const textLiteral = boldTextCall.arguments.find(a =>
+      a.type === 'Literal' && a.value === 'Claude Code');
+    editor.replaceRange(textLiteral.start, textLiteral.end,
+      '"Claude Code Extensions (cx) by x.com/@wormcoffee"');
+
+    // ── Boxed layout: b7("claude",o)("Claude Code") in the border title ──
+
+    // ── Boxed layout: b7("claude",o)("Claude Code") ──
+    // Find "Claude Code" literal whose parent CallExpression's callee is another call with "claude"
+    let titleCall = null;
+    for (const lit of claudeCodeLiterals) {
+      const call = index.parentMap.get(lit);
+      if (!call || call.type !== 'CallExpression' || call.arguments.length !== 1) continue;
+      if (call.callee.type === 'CallExpression' &&
+          call.callee.arguments[0]?.type === 'Literal' &&
+          call.callee.arguments[0].value === 'claude') {
+        titleCall = call;
+        break;
+      }
+    }
+    if (titleCall) {
+      editor.replaceRange(titleCall.arguments[0].start, titleCall.arguments[0].end,
+        '"Claude Code Extensions (cx) by x.com/@wormcoffee"');
+    }
+  },
+};

package/patches/cd-command.js

@@ -0,0 +1,104 @@
+/**
+ * /cd Command Patch
+ *
+ * Adds a /cd <path> slash command to change the working directory
+ * mid-session without losing conversation context.
+ *
+ * Addresses: https://github.com/anthropics/claude-code/issues/3473 (54 👍)
+ *
+ * AST strategy: find the bundled setCwd function (via its "tengu_shell_set_cwd"
+ * telemetry string) and getCwdState (via its named export mapping), then inject
+ * a new LocalCommand into the memoized COMMANDS array. The command calls setCwd
+ * and reports the new working directory.
+ */
+
+export default {
+  id: 'cd-command',
+  name: '/cd Command',
+  description: '/cd <path> — change where bash commands run (same as shell cd, keeps project settings)',
+
+  apply(ctx) {
+    const { ast, editor, find, query, index, src, assert } = ctx;
+
+    // ── 1. Find setCwd function via telemetry string ─────────────────
+    // setCwd logs "tengu_shell_set_cwd" on success. The shell exec function
+    // also logs it on failure, but inside an async arrow — setCwd is the
+    // only sync FunctionDeclaration containing this string.
+    const setCwdFns = query.findFunctionsContainingStrings(
+      ast, 'tengu_shell_set_cwd',
+    );
+    assert(setCwdFns.length >= 1, 'Could not find functions with tengu_shell_set_cwd');
+    const setCwdFn = setCwdFns.find(fn =>
+      fn.type === 'FunctionDeclaration' && !fn.async);
+    assert(setCwdFn, 'Could not find setCwd (sync FunctionDeclaration)');
+    const setCwdName = ctx.getFunctionName(setCwdFn);
+    assert(setCwdName, 'Could not determine setCwd function name');
+
+    // ── 2. Find getCwdState via export mapping ───────────────────────
+    // The state module exports: getCwdState:()=>XX
+    // This is a Property with Identifier key and zero-param ArrowFunction value.
+    const getCwdProp = find.findFirst(ast, n =>
+      n.type === 'Property' &&
+      n.key?.type === 'Identifier' && n.key.name === 'getCwdState' &&
+      n.value?.type === 'ArrowFunctionExpression' &&
+      n.value.params.length === 0 &&
+      n.value.body?.type === 'Identifier');
+    assert(getCwdProp, 'Could not find getCwdState export mapping');
+    const getCwdName = getCwdProp.value.body.name;
+
+    // ── 3. Find the COMMANDS array ───────────────────────────────────
+    // Locate via the compact command: find its definition object, trace to
+    // the exported variable, then find the large array containing it.
+    const compactObj = query.findObjectWithStringProps(ast, [
+      ['name', 'compact'],
+      ['type', 'local'],
+    ]);
+    assert(compactObj, 'Could not find compact command definition');
+
+    // Walk up to: localVar = {name:"compact",...}
+    let assignNode = index.parentMap.get(compactObj);
+    while (assignNode && assignNode.type !== 'AssignmentExpression') {
+      assignNode = index.parentMap.get(assignNode);
+    }
+    assert(
+      assignNode?.type === 'AssignmentExpression' &&
+      assignNode.left?.type === 'Identifier',
+      'Could not find compact assignment',
+    );
+    const localVar = assignNode.left.name;
+
+    // Find re-export: exportVar = localVar
+    const reExport = find.findFirst(ast, n =>
+      n.type === 'AssignmentExpression' &&
+      n.right?.type === 'Identifier' && n.right.name === localVar &&
+      n.left?.type === 'Identifier' && n.left.name !== localVar);
+    assert(reExport, 'Could not find compact re-export');
+    const exportVar = reExport.left.name;
+
+    // Find the array containing exportVar (COMMANDS has 40+ elements)
+    const commandsArr = find.findFirst(ast, n => {
+      if (n.type !== 'ArrayExpression') return false;
+      if (n.elements.length < 20) return false;
+      return n.elements.some(el =>
+        el?.type === 'Identifier' && el.name === exportVar);
+    });
+    assert(commandsArr, 'Could not find COMMANDS array');
+
+    // ── 4. Inject /cd command ────────────────────────────────────────
+    // Insert as last concrete element, before the closing bracket.
+    // The command calls setCwd (which validates path, resolves symlinks,
+    // updates internal state) and returns the new CWD.
+    const lastEl = commandsArr.elements[commandsArr.elements.length - 1];
+    const cdCmd =
+      `,{type:"local",name:"cd",description:"Change working directory"` +
+      `,argumentHint:"<path>",supportsNonInteractive:true` +
+      `,load:()=>Promise.resolve({call:async(q)=>{` +
+        `let p=q.trim();` +
+        `if(!p)return{type:"text",value:"Current directory: "+${getCwdName}()};` +
+        `if(p.startsWith("~"))p=(process.env.HOME||"")+p.slice(1);` +
+        `try{${setCwdName}(p);return{type:"text",value:"Changed to "+${getCwdName}()}}` +
+        `catch(e){return{type:"text",value:e.message||"Failed to change directory"}}` +
+      `}})}`;
+    editor.insertAt(lastEl.end, cdCmd);
+  },
+};

package/patches/cx-badge.js

@@ -0,0 +1,112 @@
+/**
+ * CX Badge Patch
+ *
+ * Adds a small "cx" indicator to the left of the permission mode text
+ * (e.g. "bypass permissions on", "accept edits on") in the footer.
+ * When no mode is active, the badge still shows on the footer line.
+ */
+
+export default {
+  id: 'cx-badge',
+  name: 'CX Badge',
+  description: 'Show a persistent "cx" indicator in the prompt footer',
+
+  apply(ctx) {
+    const { ast, editor, find, src, assert } = ctx;
+    const { findFirst } = find;
+
+    // Find the ModeIndicator function via the unique "? for shortcuts" string.
+    // Then locate the final return that builds <Box height={1} overflow="hidden">
+    // which contains modePart, tasksPart, and parts.
+
+    // Strategy: find the string "? for shortcuts" — it's inside a JSX element
+    // in ModeIndicator. Then find the enclosing function.
+    const shortcutsHint = findFirst(ast, n =>
+      n.type === 'Literal' && n.value === '? for shortcuts');
+    assert(shortcutsHint, 'Could not find "? for shortcuts" literal');
+
+    // Walk up to find the function containing this
+    const modeIndicatorFn = findFirst(ast, node => {
+      if (node.type !== 'FunctionDeclaration' && node.type !== 'FunctionExpression') return false;
+      // Check if the "? for shortcuts" literal is inside this function
+      let found = false;
+      const check = n => {
+        if (n === shortcutsHint) { found = true; return; }
+        if (found) return;
+        for (const key of Object.keys(n)) {
+          if (key === 'type' || key === 'start' || key === 'end') continue;
+          const val = n[key];
+          if (val && typeof val === 'object') {
+            if (Array.isArray(val)) {
+              for (const item of val) {
+                if (item && typeof item.type === 'string') check(item);
+                if (found) return;
+              }
+            } else if (typeof val.type === 'string') {
+              check(val);
+              if (found) return;
+            }
+          }
+        }
+      };
+      check(node);
+      return found;
+    });
+    assert(modeIndicatorFn, 'Could not find ModeIndicator function');
+
+    // Find the createElement call with height:1 and overflow:"hidden" props
+    // This is the final return: <Box height={1} overflow="hidden">
+    const boxWithHeight1 = findFirst(modeIndicatorFn, n => {
+      if (n.type !== 'CallExpression') return false;
+      // Look for an object argument with height:1 and overflow:"hidden"
+      return n.arguments.some(arg => {
+        if (arg?.type !== 'ObjectExpression') return false;
+        let hasHeight = false;
+        let hasOverflow = false;
+        for (const p of arg.properties) {
+          if (p.key?.name === 'height' && p.value?.value === 1) hasHeight = true;
+          if (p.key?.name === 'overflow' && p.value?.value === 'hidden') hasOverflow = true;
+        }
+        return hasHeight && hasOverflow;
+      });
+    });
+    assert(boxWithHeight1, 'Could not find <Box height={1} overflow="hidden">');
+
+    // Get the React namespace from the createElement call
+    // The call looks like: R.createElement(Box, {height:1, overflow:"hidden"}, ...children)
+    const callee = boxWithHeight1.callee;
+    let R;
+    if (callee.type === 'MemberExpression') {
+      R = src(callee.object);
+    } else {
+      // Could be jsxs or jsx direct call
+      R = src(callee);
+    }
+
+    // Find the Box component reference (first argument to createElement)
+    const BoxRef = src(boxWithHeight1.arguments[0]);
+
+    // Find the Text component — look for a createElement call with " · " string
+    const separatorCall = findFirst(modeIndicatorFn, n => {
+      if (n.type !== 'CallExpression') return false;
+      return n.arguments.some(a => a?.type === 'Literal' && a.value === ' · ');
+    });
+    assert(separatorCall, 'Could not find separator " · " createElement');
+    const TextRef = src(separatorCall.arguments[0]);
+
+    // Insert a CX badge as the first child of the Box.
+    // The children start after the props object.
+    // Find the props object position
+    const propsArg = boxWithHeight1.arguments.find(a =>
+      a?.type === 'ObjectExpression' &&
+      a.properties.some(p => p.key?.name === 'height'));
+
+    // Insert right after the props argument (before the first child)
+    const insertPos = propsArg.end;
+
+    // CX badge: inverse claude orange
+    const cxBadge = `,${R}.createElement(${BoxRef},{flexShrink:0},${R}.createElement(${TextRef},{inverse:true,color:"claude"},"cx"),${R}.createElement(${TextRef},null," "))`;
+
+    editor.insertAt(insertPos, cxBadge);
+  },
+};

package/patches/cx-resume-commands.js

@@ -0,0 +1,58 @@
+/**
+ * cx Resume Commands Patch
+ *
+ * Rewrites user-facing resume/continue command hints so they point at
+ * the cx wrapper instead of bare claude.
+ *
+ * AST strategy: scan string literals and template chunks for the stable
+ * command snippets that Claude prints to users, then replace only those
+ * substrings in-place. This covers shutdown hints, cross-project resume
+ * commands, and resume tips without relying on minified variable names.
+ */
+
+export default {
+  id: 'cx-resume-commands',
+  name: 'cx Resume Commands',
+  description: 'Show cx instead of claude in resume/continue command hints',
+
+  apply(ctx) {
+    const { ast, editor, find, src, assert } = ctx;
+    const { findAll } = find;
+
+    const replacements = [
+      ['claude --continue', 'cx --continue'],
+      ['claude --resume', 'cx --resume'],
+      ['claude -p --resume', 'cx -p --resume'],
+    ];
+
+    let changed = 0;
+    const rewrite = (node, text) => {
+      let next = text;
+      for (const [from, to] of replacements) {
+        next = next.split(from).join(to);
+      }
+      if (next !== text) {
+        editor.replaceRange(node.start, node.end, JSON.stringify(next));
+        changed++;
+      }
+    };
+
+    for (const node of findAll(ast, n => n.type === 'Literal' && typeof n.value === 'string')) {
+      rewrite(node, node.value);
+    }
+
+    for (const node of findAll(ast, n => n.type === 'TemplateElement' && typeof n.value?.raw === 'string')) {
+      const raw = src(node);
+      let nextRaw = raw;
+      for (const [from, to] of replacements) {
+        nextRaw = nextRaw.split(from).join(to);
+      }
+      if (nextRaw !== raw) {
+        editor.replaceRange(node.start, node.end, nextRaw);
+        changed++;
+      }
+    }
+
+    assert(changed >= 4, `Expected at least 4 resume/continue command rewrites, found ${changed}`);
+  },
+};

package/patches/disable-paste-collapse.js

@@ -0,0 +1,52 @@
+/**
+ * Disable Paste Collapse
+ *
+ * Prevents pasted text from being collapsed into "[Pasted text #N +X lines]"
+ * placeholders. All pasted content is inserted inline so you can review and
+ * edit it before submitting.
+ *
+ * Addresses: https://github.com/anthropics/claude-code/issues/23134 (77 👍)
+ *
+ * Strategy: find the paste-collapse condition in onTextPaste() — identified
+ * by the call to formatPastedTextRef (Xd8) which contains the stable string
+ * literal "Pasted text #" — and replace the guard condition with `false`.
+ */
+
+export default {
+  id: 'disable-paste-collapse',
+  name: 'Disable Paste Collapse',
+  description: 'Show pasted text inline instead of collapsing into [Pasted text #N]',
+
+  apply(ctx) {
+    const { ast, editor, find, src, assert } = ctx;
+    const { findFirst } = find;
+
+    // Find the formatPastedTextRef function by its "Pasted text #" template literal.
+    const fmtFn = findFirst(ast, n =>
+      n.type === 'FunctionDeclaration' &&
+      src(n).includes('Pasted text #'));
+    assert(fmtFn, 'Could not find formatPastedTextRef function');
+    const fmtName = fmtFn.id.name; // e.g. "Xd8"
+
+    // Find the onTextPaste function: contains a call to formatPastedTextRef
+    // and an if-statement whose consequent calls it.
+    // We look for the IfStatement whose consequent block contains a call
+    // to fmtName — that's the collapse gate.
+    const collapseIf = findFirst(ast, n => {
+      if (n.type !== 'IfStatement') return false;
+      // The consequent must contain a call to fmtName
+      const hasFmtCall = findFirst(n.consequent, c =>
+        c.type === 'CallExpression' &&
+        c.callee.type === 'Identifier' &&
+        c.callee.name === fmtName);
+      if (!hasFmtCall) return false;
+      // The alternate should insert text directly (else branch)
+      return n.alternate !== null;
+    });
+    assert(collapseIf, 'Could not find paste-collapse if-statement');
+
+    // Replace the test expression with `false`
+    const test = collapseIf.test;
+    editor.replaceRange(test.start, test.end, 'false');
+  },
+};

package/patches/disable-telemetry.js

@@ -0,0 +1,84 @@
+/**
+ * Disable Telemetry Patch
+ *
+ * Strips Datadog and 1P (first-party) analytics calls.
+ *
+ * Three surgical cuts:
+ * 1. Kill the analytics sink — logEvent() queues forever, nothing drains
+ * 2. Noop Datadog HTTP flush + blank endpoint — no POST to Datadog
+ * 3. Noop 1P event logging init — prevents exporter + retry of old events
+ */
+
+export default {
+  id: 'disable-telemetry',
+  name: 'Disable Telemetry',
+  description: 'Strip Datadog and 1P analytics calls',
+
+  apply(ctx) {
+    const { ast, editor, find, query, assert } = ctx;
+    const { findFirst } = find;
+
+    // ── 1. Kill the analytics sink ───────────────────────────────────────
+    // initializeAnalyticsSink() calls attachAnalyticsSink({logEvent, logEventAsync}).
+    // Replace that call with void 0 so the sink never attaches. Without a
+    // sink, logEvent() just pushes to an internal queue that never drains —
+    // neither Datadog nor 1P receives anything.
+    //
+    // Marker: object literal with preserved keys "logEvent" + "logEventAsync"
+    // passed as sole argument to a call expression.
+
+    const sinkCall = findFirst(ast, n => {
+      if (n.type !== 'CallExpression' || n.arguments.length !== 1) return false;
+      const arg = n.arguments[0];
+      if (arg.type !== 'ObjectExpression') return false;
+      const keys = arg.properties
+        .filter(p => p.type === 'Property')
+        .map(p => p.key.name || p.key.value);
+      return keys.includes('logEvent') && keys.includes('logEventAsync');
+    });
+    assert(sinkCall, 'Could not find attachAnalyticsSink({logEvent, logEventAsync})');
+    editor.replaceRange(sinkCall.start, sinkCall.end, 'void 0');
+
+    // ── 2. Noop Datadog HTTP flush + blank endpoint ─────────────────────
+    // shutdownDatadog() calls flushLogs() on exit, which would POST
+    // whatever's in logBatch. Insert early return to prevent any HTTP call.
+    //
+    // Marker: "DD-API-KEY" header string. Take the smallest zero-param
+    // function containing it (flushLogs, not a module wrapper).
+
+    const ddCandidates = query.findFunctionsContainingStrings(ast, 'DD-API-KEY');
+    const flushFns = ddCandidates
+      .filter(fn => fn.params.length === 0)
+      .sort((a, b) => (a.end - a.start) - (b.end - b.start));
+    assert(flushFns.length >= 1, 'Could not find Datadog flushLogs function');
+    const flushBody = flushFns[0].body;
+    assert(flushBody.type === 'BlockStatement', 'flushLogs: expected block body');
+    editor.insertAt(flushBody.start + 1, 'return;');
+
+    // Blank the endpoint URL as extra safety (token is not a plain literal
+    // in the bundle, so we target the URL instead).
+    const endpointLit = findFirst(ast, n =>
+      n.type === 'Literal' &&
+      n.value === 'https://http-intake.logs.us5.datadoghq.com/api/v2/logs');
+    assert(endpointLit, 'Could not find Datadog endpoint URL');
+    editor.replaceRange(endpointLit.start, endpointLit.end, '""');
+
+    // ── 3. Noop 1P event logging init ───────────────────────────────────
+    // Prevents the OpenTelemetry exporter from being created, which also
+    // stops retryPreviousBatches from re-sending old failed events.
+    //
+    // Marker: "com.anthropic.claude_code.events" instrumentation scope.
+    // Take the smallest zero-param function containing it.
+
+    const init1PCandidates = query.findFunctionsContainingStrings(
+      ast, 'com.anthropic.claude_code.events');
+    const init1PFns = init1PCandidates
+      .filter(fn => fn.params.length === 0)
+      .sort((a, b) => (a.end - a.start) - (b.end - b.start));
+    assert(init1PFns.length >= 1, 'Could not find initialize1PEventLogging');
+    const init1PBody = init1PFns[0].body;
+    assert(init1PBody.type === 'BlockStatement',
+      'initialize1PEventLogging: expected block body');
+    editor.insertAt(init1PBody.start + 1, 'return;');
+  },
+};