ziprin-context-optimizer 8.0.0

package/src/skeleton.js

@@ -0,0 +1,129 @@
+'use strict';
+
+/**
+ * Function-level skeletons + unfold one body.
+ * Optional web-tree-sitter if installed; regex otherwise.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const START_RE =
+  /^(export\s+)?(async\s+)?(function|class|const|type|interface|enum)\s+([A-Za-z_][A-Za-z0-9_]*)/;
+const ARROW_RE =
+  /^(export\s+)?(const|let)\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(async\s*)?\(/;
+
+function tryTreeSitter() {
+  try {
+    return require('web-tree-sitter');
+  } catch {
+    return null;
+  }
+}
+
+function braceEnd(lines, startIdx) {
+  let depth = 0;
+  let started = false;
+  for (let i = startIdx; i < lines.length; i++) {
+    const line = lines[i];
+    for (const ch of line) {
+      if (ch === '{') {
+        depth++;
+        started = true;
+      } else if (ch === '}') {
+        depth--;
+        if (started && depth <= 0) return i;
+      }
+    }
+    if (!started && /;\s*$/.test(line) && i > startIdx) return i;
+  }
+  return Math.min(lines.length - 1, startIdx + 40);
+}
+
+function extractSignatures(text) {
+  const lines = String(text || '').split(/\r?\n/);
+  const sigs = [];
+  for (let i = 0; i < lines.length; i++) {
+    const trim = lines[i].trim();
+    let m = START_RE.exec(trim) || ARROW_RE.exec(trim);
+    if (!m) continue;
+    const name = m[4] || m[3];
+    const kind = m[3] === 'const' || m[2] === 'const' || m[2] === 'let' ? 'const' : (m[3] || m[2] || 'fn');
+    const end = braceEnd(lines, i);
+    sigs.push({
+      name,
+      kind,
+      startLine: i + 1,
+      endLine: end + 1,
+      signature: trim.replace(/\s*\{.*$/, '').slice(0, 180),
+    });
+  }
+  return sigs;
+}
+
+function skeletonFile(root, rel, maxSigs = 24) {
+  const abs = path.join(root, rel);
+  let text = '';
+  try {
+    text = fs.readFileSync(abs, 'utf8');
+  } catch {
+    return { path: rel, mode: 'missing', signatures: [], text: '', tokenEstimate: 0 };
+  }
+  const ts = tryTreeSitter();
+  const signatures = extractSignatures(text).slice(0, maxSigs);
+  const importLines = text.split(/\r?\n/).filter((l) => /^\s*import\s/.test(l)).slice(0, 20);
+  const body = [
+    `/* SKELETON ${rel} — ${signatures.length} symbols${ts ? ' (tree-sitter available)' : ''} */`,
+    ...importLines,
+    ...signatures.map((s) => `${s.signature}  /* L${s.startLine}-${s.endLine} */`),
+    '/* unfold via ziprin_unfold_symbol */',
+  ].join('\n');
+  return {
+    path: rel,
+    mode: 'skeleton',
+    signatures,
+    text: body,
+    tokenEstimate: Math.ceil(body.length / 3.6),
+    treeSitter: Boolean(ts),
+  };
+}
+
+function unfoldSymbol(root, rel, name) {
+  const abs = path.join(root, rel);
+  let text = '';
+  try {
+    text = fs.readFileSync(abs, 'utf8');
+  } catch {
+    return { path: rel, name, mode: 'missing', text: '', tokenEstimate: 0 };
+  }
+  const sigs = extractSignatures(text);
+  const hit = sigs.find((s) => s.name === name) || sigs.find((s) => s.name.toLowerCase() === String(name).toLowerCase());
+  if (!hit) {
+    return {
+      path: rel,
+      name,
+      mode: 'not_found',
+      signatures: sigs.map((s) => s.name),
+      text: '',
+      tokenEstimate: 0,
+    };
+  }
+  const lines = text.split(/\r?\n/);
+  const slice = lines.slice(hit.startLine - 1, hit.endLine).join('\n');
+  return {
+    path: rel,
+    name: hit.name,
+    mode: 'unfold',
+    startLine: hit.startLine,
+    endLine: hit.endLine,
+    text: slice,
+    tokenEstimate: Math.ceil(slice.length / 3.6),
+  };
+}
+
+module.exports = {
+  extractSignatures,
+  skeletonFile,
+  unfoldSymbol,
+  tryTreeSitter,
+};

package/src/slice-pack.js

@@ -0,0 +1,70 @@
+'use strict';
+
+/**
+ * Vertical feature-slice packing.
+ * Prefer one complete slice (screen+api+mapper+types+local tests) over 14 unrelated files.
+ */
+
+const COMPANION_RE = [
+  { re: /\.(tsx|jsx)$/, add: ['.ts', '.api.ts', '.mapper.ts', '.types.ts', '.test.tsx', '.test.ts'] },
+  { re: /-screen\.(tsx|ts)$/, add: ['.api.ts', '.mapper.ts', '.types.ts', '.test.tsx'] },
+  { re: /\.api\.(ts|tsx)$/, add: ['.types.ts', '.mapper.ts', '.test.ts'] },
+  { re: /\.mapper\.(ts|tsx)$/, add: ['.types.ts', '.api.ts', '.test.ts'] },
+];
+
+function stem(p) {
+  return p.replace(/\.(test|spec)\.(tsx?|jsx?)$/, '').replace(/\.(tsx?|jsx?|css)$/, '');
+}
+
+function dirOf(p) {
+  const i = p.lastIndexOf('/');
+  return i === -1 ? '' : p.slice(0, i);
+}
+
+function companionPaths(seed, allPaths) {
+  const set = new Set(allPaths);
+  const out = [];
+  const d = dirOf(seed);
+  const s = stem(seed);
+  const sameDir = allPaths.filter((p) => dirOf(p) === d);
+  for (const p of sameDir) {
+    if (p === seed) continue;
+    const ps = stem(p);
+    if (ps === s || ps.startsWith(s) || s.startsWith(ps)) out.push(p);
+    if (/\.(api|mapper|types|test|spec)\./.test(p) && (p.includes(s.split('/').pop() || '___') || dirOf(p) === d)) {
+      if (!out.includes(p)) out.push(p);
+    }
+  }
+  for (const rule of COMPANION_RE) {
+    if (!rule.re.test(seed)) continue;
+    for (const extra of rule.add) {
+      const guess = s + extra.replace(/^\./, '.');
+      if (set.has(guess) && !out.includes(guess)) out.push(guess);
+    }
+  }
+  return out;
+}
+
+function packSlice(seeds, allPaths, opts = {}) {
+  const maxFiles = opts.maxFiles || 8;
+  const packed = [];
+  const seen = new Set();
+  const push = (p) => {
+    if (!p || seen.has(p) || packed.length >= maxFiles) return;
+    seen.add(p);
+    packed.push(p);
+  };
+  for (const seed of seeds.slice(0, 4)) {
+    push(seed);
+    for (const c of companionPaths(seed, allPaths)) push(c);
+    if (packed.length >= maxFiles) break;
+  }
+  return packed;
+}
+
+function isLocalTest(p, action) {
+  if (!/\/(test|spec|__tests__)\//.test(p) && !/\.(test|spec)\./.test(p)) return false;
+  return action === 'fix' || action === 'review' || /test/.test(String(action));
+}
+
+module.exports = { companionPaths, packSlice, stem, isLocalTest };

package/src/supervisor.js

@@ -0,0 +1,113 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/** Only alwaysApply file allowed after migration — replaces 6+ heavy mdc files. */
+const STUB_MDC = `---
+description: Ziprin always-on supervisor delegate — token budget. Super Guard owns rules.
+alwaysApply: true
+---
+
+# Ziprin supervisor (delegate)
+
+Live enforcement is the **Ziprin Super Guard** extension (onStartupFinished + diagnostics).
+Do **not** load other \`.cursor/rules/*.mdc\`, agents, or skills from this repository into chat.
+
+- Prefer Serena symbols, then Super Guard findings, then the fewest files.
+- Never dump whole folders. Never invent backend contracts. Never revive mock-server.
+- Auth JSON contracts and \`*.policy.json\` stay in the repo (CI). Corpus lives in Super Guard pack.
+- Call tools/skills only when they reduce tokens without harming answer quality.
+`;
+
+const STUB_REL = '.cursor/rules/ziprin-supervisor.mdc';
+
+const CURSORIGNORE_BLOCK = `
+# Ziprin Context Optimizer — token bombs
+tooling/project-index.json
+tooling/context-optimizer/project-index.json
+tooling/governance/project-must-follow-catalog.json
+tooling/super-guard/*.vsix
+**/reports/**/*.json
+.cursor/_tmp_*
+.cursor/agents/**
+.cursor/skills/**
+.cursor/sprint-manifests/
+**/node_modules/**
+`;
+
+function ensureCursorIgnore(existing) {
+  if (/Context Optimizer/.test(existing) || /tooling\/project-index\.json/.test(existing)) {
+    return existing;
+  }
+  return (existing || '').trimEnd() + '\n' + CURSORIGNORE_BLOCK;
+}
+
+function flipAlwaysApplyText(text) {
+  return text.replace(/alwaysApply:\s*true/g, 'alwaysApply: false');
+}
+
+function flipAlwaysApplyFiles(root, { write = false } = {}) {
+  const dir = path.join(root, '.cursor/rules');
+  const flipped = [];
+  if (!fs.existsSync(dir)) return { found: 0, flipped };
+  let found = 0;
+  for (const name of fs.readdirSync(dir)) {
+    if (!name.endsWith('.mdc')) continue;
+    if (name === 'ziprin-supervisor.mdc') continue;
+    const abs = path.join(dir, name);
+    const text = fs.readFileSync(abs, 'utf8');
+    if (!/alwaysApply:\s*true/.test(text)) continue;
+    found++;
+    const next = flipAlwaysApplyText(text);
+    if (next !== text) {
+      if (write) fs.writeFileSync(abs, next, 'utf8');
+      flipped.push(path.relative(root, abs).replace(/\\/g, '/'));
+    }
+  }
+  return { found, flipped };
+}
+
+/**
+ * Install token budget: one stub alwaysApply + cursorignore + optionally strip other mdc.
+ */
+function installTokenBudget(root, { write = false, stripOtherMdc = false } = {}) {
+  const report = { stub: STUB_REL, written: [], flipped: [], ignored: false, stripped: [] };
+  const stubAbs = path.join(root, STUB_REL);
+  if (write) {
+    fs.mkdirSync(path.dirname(stubAbs), { recursive: true });
+    fs.writeFileSync(stubAbs, STUB_MDC, 'utf8');
+    report.written.push(STUB_REL);
+  }
+  const ignorePath = path.join(root, '.cursorignore');
+  const prev = fs.existsSync(ignorePath) ? fs.readFileSync(ignorePath, 'utf8') : '';
+  const next = ensureCursorIgnore(prev);
+  if (write && next !== prev) {
+    fs.writeFileSync(ignorePath, next, 'utf8');
+    report.ignored = true;
+  }
+  const flip = flipAlwaysApplyFiles(root, { write });
+  report.flipped = flip.flipped;
+  if (stripOtherMdc && write) {
+    const rulesDir = path.join(root, '.cursor/rules');
+    if (fs.existsSync(rulesDir)) {
+      for (const name of fs.readdirSync(rulesDir)) {
+        if (!name.endsWith('.mdc')) continue;
+        if (name === 'ziprin-supervisor.mdc') continue;
+        fs.unlinkSync(path.join(rulesDir, name));
+        report.stripped.push('.cursor/rules/' + name);
+      }
+    }
+  }
+  return report;
+}
+
+module.exports = {
+  STUB_MDC,
+  STUB_REL,
+  CURSORIGNORE_BLOCK,
+  ensureCursorIgnore,
+  flipAlwaysApplyText,
+  flipAlwaysApplyFiles,
+  installTokenBudget,
+};

package/src/task-analyzer.js

@@ -0,0 +1,189 @@
+'use strict';
+
+const {
+  tokenize,
+  expandSynonyms,
+  extractSymbols,
+  extractPathHints,
+  detectDomain: detectDomainLang,
+  analyzePrompt,
+} = require('./language');
+
+const CATEGORIES = {
+  frontend: {
+    id: 'frontend',
+    label: 'Frontend UI',
+    includeHints: ['react', 'components', 'design', 'styles', 'tsx', 'css', 'layout', 'ui', 'کامپوننت', 'صفحه', 'فرم'],
+    deprioritize: ['database', 'migration', 'repository'],
+    profileId: 'frontend',
+  },
+  backend: {
+    id: 'backend',
+    label: 'Backend',
+    includeHints: ['service', 'controller', 'repository', 'schema', 'api', 'server', 'rtk', 'endpoint', 'ایپیای'],
+    deprioritize: ['css', 'tailwind', 'figma', 'layout'],
+    profileId: 'backend',
+  },
+  architecture: {
+    id: 'architecture',
+    label: 'Architecture',
+    includeHints: ['architecture', 'governance', 'dependency', 'boundary', 'policy', 'معماری', 'لایه', 'قانون'],
+    deprioritize: [],
+    profileId: 'architecture',
+  },
+  mixed: {
+    id: 'mixed',
+    label: 'Mixed',
+    includeHints: [],
+    deprioritize: [],
+    profileId: 'standard',
+  },
+};
+
+const DOMAIN_RULES = [
+  {
+    id: 'bss_vendor',
+    match: /\b(bss|vendor|product.?status|dashboard\/bss|portals\/vendor|فروشنده|افزودن محصول)\b/i,
+    priorityPaths: ['apps/dashboard/bss/src/portals/vendor', 'apps/dashboard/bss/src'],
+    label: 'BSS Vendor',
+  },
+  {
+    id: 'bss_dashboard',
+    match: /\b(bss|dashboard|تیکت|ticket|پنل)\b/i,
+    priorityPaths: ['apps/dashboard/bss/src', 'apps/dashboard'],
+    label: 'BSS Dashboard',
+  },
+  {
+    id: 'marketplace',
+    match: /\b(marketplace|shop|cart|checkout|catalog|مارکت|بازار|سبد)\b/i,
+    priorityPaths: ['apps/marketplace/src'],
+    label: 'Marketplace',
+  },
+];
+
+function scoreCategory(tokens, category) {
+  let score = 0;
+  for (const hint of category.includeHints) {
+    if (tokens.some((t) => t.includes(hint) || hint.includes(t))) score += 10;
+  }
+  for (const bad of category.deprioritize) {
+    if (tokens.some((t) => t.includes(bad))) score -= 5;
+  }
+  return score;
+}
+
+function detectDomain(prompt) {
+  return detectDomainLang(prompt);
+}
+
+function detectAction(prompt) {
+  const p = String(prompt || '').toLowerCase();
+  if (/\bfix\b|\bbug\b|\berror\b|\bcrash\b|\bbroken\b|باگ|خطا|ارور|خراب|فیکس/.test(p)) return 'fix';
+  if (/\breview\b|\baudit\b|\binspect\b|بررسی/.test(p)) return 'review';
+  if (/\brefactor\b|cleanup|simplify|\bextract\b|بازسازی/.test(p)) return 'refactor';
+  if (/\badd\b|\bimplement\b|\bcreate\b|\bbuild\b|\bwire\b|اضافه|بساز|پیاده/.test(p)) return 'implement';
+  if (/\bmigrate\b|\bupgrade\b|\bmove\b/.test(p)) return 'migrate';
+  if (/architecture|structure|boundary|\bdesign\b|معماری|لایه/.test(p)) return 'architecture';
+  return 'general';
+}
+
+function detectScope(prompt, domain) {
+  const p = String(prompt || '');
+  if (/entire|whole|across|all apps|monorepo|کل پروژه/.test(p)) return 'monorepo';
+  if (domain?.id) return domain.id;
+  if (/marketplace|مارکت/.test(p)) return 'marketplace';
+  if (/bss|dashboard|vendor|فروشنده|تیکت/.test(p)) return 'bss';
+  return 'feature';
+}
+
+function detectRisk(prompt, complexity) {
+  if (/auth|payment|checkout|password|secret|credential|پرداخت|ورود/.test(prompt)) return 'high';
+  if (complexity === 'architecture_review') return 'medium';
+  if (/delete|remove|migrate|breaking|حذف/.test(prompt)) return 'medium';
+  return 'low';
+}
+
+function buildIntent(prompt, domain, complexity) {
+  return {
+    action: detectAction(prompt),
+    domain: domain?.id || null,
+    domainLabel: domain?.label || null,
+    scope: detectScope(prompt, domain),
+    complexity,
+    risk: detectRisk(prompt, complexity),
+  };
+}
+
+function analyzeTask(prompt, preferredProfileId, memory) {
+  const lang = analyzePrompt(prompt, memory);
+  const tokens = lang.expanded.length ? lang.expanded : lang.tokens;
+  const scores = {
+    frontend: scoreCategory(tokens, CATEGORIES.frontend),
+    backend: scoreCategory(tokens, CATEGORIES.backend),
+    architecture: scoreCategory(tokens, CATEGORIES.architecture),
+  };
+
+  let category = 'mixed';
+  let best = 0;
+  for (const [id, s] of Object.entries(scores)) {
+    if (s > best) {
+      best = s;
+      category = id;
+    }
+  }
+  if (best < 10) category = 'mixed';
+
+  const cat = CATEGORIES[category];
+  const profileId =
+    preferredProfileId && preferredProfileId !== 'standard' ? preferredProfileId : cat.profileId;
+
+  const complexity =
+    tokens.length > 40 || /refactor|architecture|migrate|entire|across|معماری/i.test(prompt)
+      ? 'architecture_review'
+      : category === 'frontend' && !/api|server|service|database|repository/i.test(prompt)
+        ? 'simple_ui_fix'
+        : /bug|error|fix|crash|fail|باگ|خطا/i.test(prompt) || category === 'backend'
+          ? 'backend_bug'
+          : 'mixed';
+
+  const domain = lang.domain;
+  const symbols = lang.symbols;
+  const pathHints = lang.pathHints;
+  const intent = buildIntent(prompt, domain, complexity);
+
+  return {
+    category: cat.id,
+    label: cat.label,
+    scores,
+    profileId,
+    complexity,
+    tokens,
+    includeHints: cat.includeHints,
+    deprioritize: cat.deprioritize,
+    strategy: `Focus ${cat.label}${domain ? ` / ${domain.label}` : ''}; action=${intent.action}; deprioritize ${cat.deprioritize.join(', ') || 'none'}.`,
+    domain,
+    symbols,
+    pathHints,
+    intent,
+    language: {
+      originalTokens: lang.tokens,
+      expanded: lang.expanded,
+      identifierParts: lang.identifierParts || [],
+      rewrite: lang.rewrite || null,
+    },
+    identifierParts: lang.identifierParts || [],
+    rewrite: lang.rewrite || null,
+  };
+}
+
+module.exports = {
+  analyzeTask,
+  CATEGORIES,
+  DOMAIN_RULES,
+  tokenize,
+  extractSymbols,
+  extractPathHints,
+  detectDomain,
+  buildIntent,
+  expandSynonyms,
+};

package/src/tool-router.js

@@ -0,0 +1,92 @@
+'use strict';
+
+/**
+ * Decide whether calling a tool/skill/plugin first reduces tokens without quality loss.
+ * Principle: structural lookup tools beat dumping agents/skills/rules into the prompt.
+ */
+
+const ROUTES = [
+  {
+    id: 'serena-symbol',
+    match: /symbol|definition|where is|find class|find function|پیاده‌سازی|کجا تعریف/i,
+    tool: 'serena',
+    savesTokens: 'high',
+    qualitySafe: true,
+    why: 'Symbol graph answers location without loading whole files',
+  },
+  {
+    id: 'grep-exact',
+    match: /grep|search string|find usage|where used|جستجو|استفاده شده/i,
+    tool: 'grep',
+    savesTokens: 'high',
+    qualitySafe: true,
+    why: 'Exact string search is cheaper than loading folders',
+  },
+  {
+    id: 'super-guard-scan',
+    match: /lint|rule|architecture|boundary|violation|قانون|معماری|نقض/i,
+    tool: 'ziprinSuperGuard.scanCurrentFile',
+    savesTokens: 'medium',
+    qualitySafe: true,
+    why: 'Local rule engine replaces loading all .mdc into chat',
+  },
+  {
+    id: 'read-single',
+    match: /open file|read this|show me|این فایل/i,
+    tool: 'read_file',
+    savesTokens: 'medium',
+    qualitySafe: true,
+    why: 'Targeted read beats @folder',
+  },
+  {
+    id: 'avoid-agents-dump',
+    match: /./,
+    tool: null,
+    skip: ['.cursor/agents', '.cursor/skills', 'tooling/project-index.json'],
+    savesTokens: 'high',
+    qualitySafe: true,
+    why: 'Agents/skills corpus is in Super Guard pack — do not paste into chat',
+  },
+];
+
+function routeTask(task) {
+  const t = String(task || '');
+  const hits = [];
+  for (const r of ROUTES) {
+    if (r.match.test(t)) {
+      hits.push({
+        id: r.id,
+        tool: r.tool,
+        skip: r.skip || [],
+        savesTokens: r.savesTokens,
+        qualitySafe: r.qualitySafe,
+        why: r.why,
+      });
+    }
+  }
+  // Prefer concrete tools over the catch-all avoid dump
+  const concrete = hits.filter((h) => h.tool);
+  const plan = concrete.length ? concrete : hits;
+  return {
+    task: t,
+    plan,
+    recommendation: plan[0] || null,
+    neverDump: ['.cursor/agents/**', '.cursor/skills/**', '**/reports/**', 'tooling/project-index.json'],
+  };
+}
+
+function shouldInstallSkill(skillName, task) {
+  // Only "install"/invoke a skill if it is task-local and quality-safe
+  const name = String(skillName || '').toLowerCase();
+  const t = String(task || '').toLowerCase();
+  if (!name || !t) return { ok: false, why: 'missing skill or task' };
+  if (name.includes('agent') && t.length < 20) {
+    return { ok: false, why: 'Short tasks should not pull whole agents' };
+  }
+  if (t.includes(name) || name.split(/[-_]/).some((p) => p.length > 3 && t.includes(p))) {
+    return { ok: true, why: 'Skill name appears relevant to task; invoke on-demand only' };
+  }
+  return { ok: false, why: 'Skill not clearly relevant — skip to save tokens' };
+}
+
+module.exports = { ROUTES, routeTask, shouldInstallSkill };

package/src/version.js

@@ -0,0 +1,5 @@
+'use strict';
+
+const VERSION = '8.0.0';
+
+module.exports = { VERSION };

package/templates/ziprin-context-mcp.mjs

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+/**
+ * Thin MCP launcher — plugin runtime in ~/.ziprin (installed via npm setup).
+ * Install/update: npx @ziprin/context-optimizer setup --workspace /path/to/repo
+ */
+
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const home = os.homedir();
+const manifestFile = path.join(home, ".ziprin", "ziprin-context-install.json");
+const defaultRoot = path.join(home, ".ziprin", "ziprin-context-optimizer");
+
+function resolveRoot() {
+  if (process.env.ZIPRIN_CONTEXT_PLUGIN) {
+    return path.resolve(process.env.ZIPRIN_CONTEXT_PLUGIN);
+  }
+  if (fs.existsSync(manifestFile)) {
+    try {
+      const m = JSON.parse(fs.readFileSync(manifestFile, "utf8"));
+      if (m.pluginRoot && fs.existsSync(path.join(m.pluginRoot, "src", "mcp-server.js"))) {
+        return m.pluginRoot;
+      }
+    } catch {
+      /* ignore */
+    }
+  }
+  return defaultRoot;
+}
+
+const workspace = process.env.ZIPRIN_WORKSPACE
+  ? path.resolve(process.env.ZIPRIN_WORKSPACE)
+  : path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const pluginRoot = resolveRoot();
+const entry = path.join(pluginRoot, "src", "mcp-server.js");
+
+if (!fs.existsSync(entry)) {
+  console.error(
+    `[ziprin-context] MCP not installed. Run:\n  npx @ziprin/context-optimizer setup --workspace "${workspace}"`,
+  );
+  process.exit(1);
+}
+
+const child = spawn(process.execPath, [entry, "--project", workspace], {
+  stdio: "inherit",
+  env: { ...process.env, ZIPRIN_WORKSPACE: workspace, ZIPRIN_CONTEXT_PLUGIN: pluginRoot },
+  windowsHide: true,
+});
+
+child.on("exit", (code, signal) => {
+  if (signal) {
+    try {
+      process.kill(process.pid, signal);
+    } catch {
+      process.exit(1);
+    }
+    return;
+  }
+  process.exit(code ?? 1);
+});
+
+child.on("error", (err) => {
+  console.error("[ziprin-context]", err.message);
+  process.exit(1);
+});