delimit-cli 4.1.53 → 4.3.0

package/lib/wrap-engine.js

@@ -0,0 +1,431 @@
+// lib/wrap-engine.js
+//
+// LED-1048: `delimit wrap` — Surface 1 CLI-pipe extension
+// LED-1052: Kill Switch + cross-model handoff extension
+//
+// Runs an arbitrary command (typically `claude -p` or `cursor` or `codex`),
+// snapshots repo state before/after, runs governance gates on the diff,
+// emits a signed attestation JSON + replay URL reference.
+//
+// Advisory-first: exit 0 unless --enforce is set AND gates fail.
+// Cross-model-agnostic: the wrapped command is arbitrary, not bound to Claude.
+//
+// Kill Switch (LED-1052): --max-time <seconds> caps wall-clock; on SIGKILL
+// the attestation emitted is typed as kind=liability_incident and includes
+// a handoff_suggestion field pointing the user at an alternative producer.
+
+const { spawn, spawnSync, execSync } = require('child_process');
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// ----------------------------------------------------------------------------
+// Git helpers — snapshot before/after a wrapped command
+// ----------------------------------------------------------------------------
+
+function safeExec(cmd, opts = {}) {
+    try {
+        return execSync(cmd, { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'], ...opts }).trim();
+    } catch {
+        return null;
+    }
+}
+
+function getRepoRoot(cwd) {
+    return safeExec('git rev-parse --show-toplevel', { cwd }) || cwd;
+}
+
+function getCurrentHead(cwd) {
+    return safeExec('git rev-parse HEAD', { cwd });
+}
+
+function getDirtyFiles(cwd) {
+    // Don't use safeExec because .trim() mangles the leading-space porcelain format.
+    try {
+        const raw = execSync('git status --porcelain', { cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'] });
+        // Porcelain format: XY<space><path>  (XY is always 2 chars, e.g. " M", "??", "MM")
+        return raw.split('\n').filter(Boolean).map(l => l.slice(3));
+    } catch {
+        return [];
+    }
+}
+
+function getUnifiedDiff(cwd, fromHead) {
+    if (!fromHead) return '';
+    // Diff against the snapshot: tracked changes + untracked files (as if added)
+    return safeExec(`git diff ${fromHead} -- .`, { cwd }) || '';
+}
+
+// ----------------------------------------------------------------------------
+// Governance gate composition — reuse existing CLI subcommands where possible
+// ----------------------------------------------------------------------------
+
+function detectOpenAPISpecChanges(changedFiles, cwd) {
+    // Simple heuristic: files matching openapi*.yaml / openapi*.json / swagger.*
+    const specs = changedFiles.filter(f => {
+        const base = path.basename(f).toLowerCase();
+        return /(^openapi|\.openapi|swagger)\.(ya?ml|json)$/.test(base) || base === 'openapi.yaml';
+    });
+    return specs;
+}
+
+function runDelimitCLI(args, cwd) {
+    // Invoke the sibling CLI entry point directly to avoid PATH assumptions.
+    const cliPath = path.join(__dirname, '..', 'bin', 'delimit-cli.js');
+    try {
+        const result = spawnSync('node', [cliPath, ...args, '--json'], {
+            cwd,
+            encoding: 'utf-8',
+            timeout: 60000,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const stdout = result.stdout || '';
+        const stderr = result.stderr || '';
+        let parsed = null;
+        try {
+            // Find last JSON object in stdout (cli may print banner before)
+            const m = stdout.match(/\{[\s\S]*\}\s*$/);
+            if (m) parsed = JSON.parse(m[0]);
+        } catch { /* leave null */ }
+        return { exit: result.status ?? 1, stdout, stderr, parsed };
+    } catch (e) {
+        return { exit: 1, stdout: '', stderr: String(e), parsed: null };
+    }
+}
+
+function runTestSmoke(cwd) {
+    // Minimal heuristic: if pytest is available and tests/ exists, run it.
+    // If package.json has a test script, run `npm test`.
+    // Time-bounded. Advisory. Never the block criterion alone.
+    const results = [];
+    const pkgPath = path.join(cwd, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            if (pkg.scripts && pkg.scripts.test && pkg.scripts.test !== 'echo "Error: no test specified" && exit 1') {
+                const r = spawnSync('npm', ['test', '--silent'], { cwd, encoding: 'utf-8', timeout: 120000, stdio: ['ignore', 'pipe', 'pipe'] });
+                results.push({ runner: 'npm test', exit: r.status ?? 1, stdout: (r.stdout || '').slice(-2000), stderr: (r.stderr || '').slice(-1000) });
+            }
+        } catch { /* ignore */ }
+    }
+    if (fs.existsSync(path.join(cwd, 'tests')) || fs.existsSync(path.join(cwd, 'pytest.ini')) || fs.existsSync(path.join(cwd, 'pyproject.toml'))) {
+        const r = spawnSync('python3', ['-m', 'pytest', '--tb=short', '-q'], { cwd, encoding: 'utf-8', timeout: 180000, stdio: ['ignore', 'pipe', 'pipe'] });
+        results.push({ runner: 'pytest', exit: r.status ?? 1, stdout: (r.stdout || '').slice(-2000), stderr: (r.stderr || '').slice(-1000) });
+    }
+    return results;
+}
+
+// ----------------------------------------------------------------------------
+// Attestation bundling + signing
+// ----------------------------------------------------------------------------
+
+function computeAttestationId(bundle) {
+    const canonical = JSON.stringify(bundle, Object.keys(bundle).sort());
+    const hash = crypto.createHash('sha256').update(canonical).digest('hex');
+    return 'att_' + hash.slice(0, 16);
+}
+
+function loadOrCreateHmacKey() {
+    // Local HMAC key for attestation signing.
+    // Cloud-sync + verifiable signature is a Pro/Premium feature (deferred MVP).
+    const keyPath = path.join(os.homedir(), '.delimit', 'wrap-hmac.key');
+    if (fs.existsSync(keyPath)) return fs.readFileSync(keyPath);
+    const key = crypto.randomBytes(32);
+    fs.mkdirSync(path.dirname(keyPath), { recursive: true });
+    fs.writeFileSync(keyPath, key, { mode: 0o600 });
+    return key;
+}
+
+function signAttestation(bundle) {
+    const key = loadOrCreateHmacKey();
+    const canonical = JSON.stringify(bundle, Object.keys(bundle).sort());
+    return crypto.createHmac('sha256', key).update(canonical).digest('hex');
+}
+
+// ----------------------------------------------------------------------------
+// Quota enforcement — free tier 3 lifetime, Pro unlimited
+// ----------------------------------------------------------------------------
+
+function checkQuota() {
+    const counterPath = path.join(os.homedir(), '.delimit', 'wrap-lifetime-count');
+    const licensePath = path.join(os.homedir(), '.delimit', 'license.json');
+    let tier = 'free';
+    try {
+        if (fs.existsSync(licensePath)) {
+            const lic = JSON.parse(fs.readFileSync(licensePath, 'utf-8'));
+            if (lic.valid && ['pro', 'premium', 'enterprise'].includes(lic.tier)) {
+                tier = lic.tier;
+            }
+        }
+    } catch { /* treat as free */ }
+    if (tier !== 'free') return { ok: true, tier, count: null };
+    let count = 0;
+    try {
+        if (fs.existsSync(counterPath)) count = parseInt(fs.readFileSync(counterPath, 'utf-8').trim(), 10) || 0;
+    } catch { /* start at 0 */ }
+    return { ok: count < 3, tier: 'free', count, limit: 3 };
+}
+
+function incrementQuota() {
+    const counterPath = path.join(os.homedir(), '.delimit', 'wrap-lifetime-count');
+    let count = 0;
+    try {
+        if (fs.existsSync(counterPath)) count = parseInt(fs.readFileSync(counterPath, 'utf-8').trim(), 10) || 0;
+    } catch {}
+    count += 1;
+    fs.mkdirSync(path.dirname(counterPath), { recursive: true });
+    fs.writeFileSync(counterPath, String(count));
+    return count;
+}
+
+// ----------------------------------------------------------------------------
+// Persistence — save attestation to local ledger
+// ----------------------------------------------------------------------------
+
+function saveAttestation(att) {
+    const dir = path.join(os.homedir(), '.delimit', 'attestations');
+    fs.mkdirSync(dir, { recursive: true });
+    const file = path.join(dir, `${att.id}.json`);
+    fs.writeFileSync(file, JSON.stringify(att, null, 2));
+    return file;
+}
+
+function replayUrl(attId) {
+    // Public replay surface is served by app.delimit.ai (reuses the trust-page
+    // pattern from LED-1018). For MVP, just returns the URL; rendering + upload
+    // is the Pro-tier feature and not part of this MVP.
+    return `https://delimit.ai/att/${attId}`;
+}
+
+// ----------------------------------------------------------------------------
+// Main wrap flow
+// ----------------------------------------------------------------------------
+
+// LED-1052: map a wrapped command's base binary to a handoff suggestion
+// for the remaining producers. Advisory only — prints the command a user
+// could run to resume with a different model.
+function suggestHandoff(rawCmd) {
+    const bin = (rawCmd && rawCmd[0]) || '';
+    const base = path.basename(bin).toLowerCase();
+    const prompt = extractPromptArg(rawCmd);
+    const fallbacks = {
+        claude: ['codex', 'gemini', 'cursor'],
+        'claude-code': ['codex', 'gemini', 'cursor'],
+        cursor: ['claude', 'codex', 'gemini'],
+        'cursor-cli': ['claude', 'codex', 'gemini'],
+        aider: ['claude', 'codex', 'gemini'],
+        codex: ['claude', 'gemini', 'cursor'],
+        gemini: ['claude', 'codex', 'cursor'],
+    };
+    const key = Object.keys(fallbacks).find(k => base.includes(k));
+    if (!key) return null;
+    const alt = fallbacks[key][0];
+    const altPrompt = prompt || '<your-goal>';
+    return {
+        kill_source: key,
+        handoff_target: alt,
+        suggested_command: `delimit wrap -- ${alt} -p "${altPrompt}"`,
+        alternates: fallbacks[key],
+    };
+}
+
+function extractPromptArg(rawCmd) {
+    // Best-effort scrape: -p <prompt> or --prompt <prompt>
+    if (!rawCmd) return null;
+    for (let i = 0; i < rawCmd.length - 1; i++) {
+        if (rawCmd[i] === '-p' || rawCmd[i] === '--prompt') return rawCmd[i + 1];
+    }
+    return null;
+}
+
+// LED-1052: spawn a child with wall-clock timeout + SIGKILL on breach.
+// Returns { status, killed_by_timeout, ms }.
+function spawnWithKillSwitch(bin, args, spawnOpts, maxTimeSeconds) {
+    return new Promise((resolve) => {
+        const child = spawn(bin, args, { ...spawnOpts, stdio: 'inherit' });
+        const started = Date.now();
+        let killed = false;
+        const timer = maxTimeSeconds && maxTimeSeconds > 0
+            ? setTimeout(() => {
+                killed = true;
+                try { child.kill('SIGKILL'); } catch { /* ignore */ }
+            }, maxTimeSeconds * 1000)
+            : null;
+        child.on('close', (code, signal) => {
+            if (timer) clearTimeout(timer);
+            resolve({
+                status: (code !== null ? code : (signal === 'SIGKILL' ? 137 : 1)),
+                killed_by_timeout: killed,
+                signal,
+                ms: Date.now() - started,
+            });
+        });
+        child.on('error', (err) => {
+            if (timer) clearTimeout(timer);
+            resolve({ status: 1, killed_by_timeout: false, error: String(err), ms: Date.now() - started });
+        });
+    });
+}
+
+async function runWrap(rawCmd, options = {}) {
+    const {
+        enforce = false,
+        deliberate = false,
+        attest = true,
+        cwd = process.cwd(),
+        maxTimeSeconds = 0,  // LED-1052: 0 disables kill switch
+    } = options;
+
+    const repoRoot = getRepoRoot(cwd);
+    const isGitRepo = !!safeExec('git rev-parse --is-inside-work-tree', { cwd: repoRoot });
+
+    // Quota check (only if attestation will be emitted)
+    let quotaInfo = null;
+    if (attest) {
+        quotaInfo = checkQuota();
+        if (!quotaInfo.ok) {
+            return {
+                exit: 1,
+                error: 'quota_exceeded',
+                message: `Free tier: ${quotaInfo.count}/${quotaInfo.limit} lifetime attestations used. Upgrade to Pro ($10/mo) for unlimited — visit https://delimit.ai/pricing`,
+                tier: quotaInfo.tier,
+            };
+        }
+    }
+
+    // Snapshot before
+    const beforeHead = isGitRepo ? getCurrentHead(repoRoot) : null;
+    const beforeDirty = isGitRepo ? getDirtyFiles(repoRoot) : [];
+    const startedAt = new Date().toISOString();
+
+    // Execute the wrapped command
+    // The wrapped command runs in the user's shell so `claude -p "..."` / `cursor edit` / etc. work natively.
+    // LED-1052: if maxTimeSeconds > 0, use async spawnWithKillSwitch; otherwise spawnSync for back-compat.
+    let wrappedExit;
+    let killedByTimeout = false;
+    let killSignal = null;
+    if (maxTimeSeconds > 0) {
+        const res = await spawnWithKillSwitch(rawCmd[0], rawCmd.slice(1), { cwd: repoRoot, shell: false }, maxTimeSeconds);
+        wrappedExit = res.status;
+        killedByTimeout = res.killed_by_timeout;
+        killSignal = res.signal || null;
+    } else {
+        const child = spawnSync(rawCmd[0], rawCmd.slice(1), { cwd: repoRoot, stdio: 'inherit', shell: false });
+        wrappedExit = child.status ?? 1;
+    }
+    const completedAt = new Date().toISOString();
+
+    // Snapshot after
+    const afterHead = isGitRepo ? getCurrentHead(repoRoot) : null;
+    const afterDirty = isGitRepo ? getDirtyFiles(repoRoot) : [];
+    const changedFiles = isGitRepo
+        ? Array.from(new Set([...beforeDirty, ...afterDirty]))
+        : [];
+
+    // Governance chain
+    const governance = { gates: [], violations: [], advisory: !enforce };
+
+    // 1) OpenAPI spec changes → delimit lint / diff
+    const specChanges = detectOpenAPISpecChanges(changedFiles, repoRoot);
+    if (specChanges.length > 0) {
+        governance.gates.push({ name: 'openapi_detect', result: 'ran', specs: specChanges });
+        // Try running delimit lint on each (zero-spec mode against baseline)
+        for (const spec of specChanges) {
+            const lintResult = runDelimitCLI(['lint'], path.dirname(path.join(repoRoot, spec)));
+            governance.gates.push({
+                name: 'delimit_lint',
+                spec,
+                exit: lintResult.exit,
+                summary: (lintResult.stdout || '').slice(-500),
+            });
+            if (lintResult.exit !== 0) governance.violations.push(`lint failed on ${spec}`);
+        }
+    }
+
+    // 2) Test smoke
+    const testResults = runTestSmoke(repoRoot);
+    for (const t of testResults) {
+        governance.gates.push({ name: 'test_smoke', runner: t.runner, exit: t.exit });
+        if (t.exit !== 0) governance.violations.push(`${t.runner} failed`);
+    }
+    if (testResults.length === 0) {
+        governance.gates.push({ name: 'test_smoke', result: 'no_tests_detected' });
+    }
+
+    // 3) Multi-model deliberate (optional)
+    if (deliberate) {
+        governance.gates.push({ name: 'deliberate', result: 'deferred', note: 'use `delimit deliberate` standalone for multi-model verdict — v1 wrap emits local attestation only' });
+    }
+
+    // Build attestation bundle
+    // LED-1052: if killed by timeout, attestation is typed as liability_incident
+    const kind = killedByTimeout ? 'liability_incident' : 'merge_attestation';
+    const handoffSuggestion = killedByTimeout ? suggestHandoff(rawCmd) : null;
+    const bundle = {
+        schema: 'delimit.attestation.v1',
+        kind,
+        wrapped_command: rawCmd.join(' '),
+        repo_root: repoRoot,
+        is_git_repo: isGitRepo,
+        before_head: beforeHead,
+        after_head: afterHead,
+        started_at: startedAt,
+        completed_at: completedAt,
+        wrapped_exit: wrappedExit,
+        changed_files: changedFiles,
+        governance,
+        delimit_wrap_version: '1.1.0',
+        ...(killedByTimeout ? {
+            kill_switch: {
+                kind: 'timeout',
+                max_time_seconds: maxTimeSeconds,
+                signal: killSignal,
+                handoff_suggestion: handoffSuggestion,
+            },
+        } : {}),
+    };
+    const attId = computeAttestationId(bundle);
+    const signature = signAttestation(bundle);
+    const attestation = {
+        id: attId,
+        bundle,
+        signature,
+        signature_alg: 'HMAC-SHA256',
+    };
+
+    let filePath = null;
+    if (attest) {
+        filePath = saveAttestation(attestation);
+        if (quotaInfo && quotaInfo.tier === 'free') incrementQuota();
+    }
+
+    const hasViolations = governance.violations.length > 0;
+    const shouldFail = enforce && hasViolations;
+
+    return {
+        exit: shouldFail ? 2 : wrappedExit,
+        attestation_id: attId,
+        attestation_path: filePath,
+        replay_url: replayUrl(attId),
+        kind,
+        violations: governance.violations,
+        gates: governance.gates,
+        wrapped_exit: wrappedExit,
+        advisory: !enforce,
+        tier: quotaInfo ? quotaInfo.tier : null,
+        // LED-1052: kill-switch metadata surfaced at the top level for CLI rendering
+        ...(killedByTimeout ? {
+            killed_by_timeout: true,
+            handoff_suggestion: handoffSuggestion,
+        } : {}),
+    };
+}
+
+module.exports = {
+    runWrap,
+    computeAttestationId,
+    signAttestation,
+    checkQuota,
+    replayUrl,
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "delimit-cli",
   "mcpName": "io.github.delimit-ai/delimit-mcp-server",
-  "version": "4.1.53",
+  "version": "4.3.0",
   "description": "Unify Claude Code, Codex, Cursor, and Gemini CLI with persistent context, governance, and multi-model debate.",
   "main": "index.js",
   "files": [
@@ -11,17 +11,30 @@
     "gateway/",
     "!gateway/ai/social_target.py",
     "!gateway/ai/social.py",
+    "!gateway/ai/social_daemon.py",
+    "!gateway/ai/social_cache.py",
     "!gateway/ai/founding_users.py",
     "!gateway/ai/inbox_daemon.py",
+    "!gateway/ai/inbox_daemon_runner.py",
     "!gateway/ai/deliberation.py",
     "!gateway/ai/dv_mention_tracker.py",
     "!gateway/ai/sensor_twttr.py",
     "!gateway/ai/tweet_corpus.py",
+    "!gateway/ai/tweet_corpus_schema.sql",
     "!gateway/ai/twttr241_budget.py",
     "!gateway/ai/wireintel_x.py",
     "!gateway/ai/content_intel.py",
     "!gateway/ai/loop_daemon.py",
+    "!gateway/ai/loop_engine.py",
     "scripts/",
+    "!scripts/crosspost_devto.py",
+    "!scripts/repo_targeting.py",
+    "!scripts/outreach_report_generator.py",
+    "!scripts/demo-v420.sh",
+    "!scripts/demo-v420-clean.sh",
+    "!scripts/demo-v420-deliberation.sh",
+    "!scripts/sync-gateway.sh",
+    "!gateway/ai/continuity.py",
     "server.json",
     "README.md",
     "LICENSE",

package/adapters/codex-security.js

@@ -1,64 +0,0 @@
-#!/usr/bin/env node
-/**
- * Delimit Security Skill for Codex CLI
- *
- * Validates that Codex-generated code doesn't introduce security anti-patterns.
- * Runs as a security validation skill.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const SECURITY_PATTERNS = [
-    { pattern: /eval\s*\(/g, severity: 'high', message: 'eval() usage detected — potential code injection' },
-    { pattern: /exec\s*\(/g, severity: 'medium', message: 'exec() usage — verify input sanitization' },
-    { pattern: /shell\s*=\s*True/g, severity: 'high', message: 'subprocess with shell=True — command injection risk' },
-    { pattern: /dangerouslySetInnerHTML/g, severity: 'medium', message: 'dangerouslySetInnerHTML — XSS risk' },
-    { pattern: /password\s*=\s*["'][^"']+["']/gi, severity: 'high', message: 'Hardcoded password detected' },
-    { pattern: /api[_-]?key\s*=\s*["'][A-Za-z0-9]{10,}["']/gi, severity: 'high', message: 'Hardcoded API key detected' },
-];
-
-function checkSecurity(context) {
-    const code = context.code || context.content || '';
-    if (!code) return { status: 'clean', findings: [] };
-
-    const findings = [];
-    for (const { pattern, severity, message } of SECURITY_PATTERNS) {
-        const matches = code.match(pattern);
-        if (matches) {
-            findings.push({ severity, message, count: matches.length });
-        }
-    }
-
-    // Audit
-    try {
-        const auditDir = path.join(process.env.HOME || '', '.delimit', 'audit');
-        fs.mkdirSync(auditDir, { recursive: true });
-        const record = {
-            timestamp: new Date().toISOString(),
-            source: 'codex-security',
-            findings_count: findings.length,
-            high_count: findings.filter(f => f.severity === 'high').length,
-        };
-        const auditFile = path.join(auditDir, `${new Date().toISOString().split('T')[0]}.jsonl`);
-        fs.appendFileSync(auditFile, JSON.stringify(record) + '\n');
-    } catch {}
-
-    const hasHigh = findings.some(f => f.severity === 'high');
-    return {
-        status: hasHigh ? 'flagged' : findings.length > 0 ? 'warnings' : 'clean',
-        findings,
-    };
-}
-
-const context = process.argv[2] ? JSON.parse(process.argv[2]) : {};
-const result = checkSecurity(context);
-
-if (result.status === 'flagged') {
-    for (const f of result.findings) {
-        console.error(`[Delimit Security] ${f.severity.toUpperCase()}: ${f.message}`);
-    }
-    process.exit(1);
-}
-
-process.exit(0);

package/adapters/codex-skill.js

@@ -1,78 +0,0 @@
-#!/usr/bin/env node
-/**
- * Delimit Governance Skill for Codex CLI
- *
- * Runs as a validation skill triggered on pre-code-generation and pre-suggestion.
- * Checks governance state and policy compliance before Codex executes actions.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const DELIMIT_HOME = path.join(process.env.HOME || '', '.delimit');
-const MODE_FILE = path.join(DELIMIT_HOME, 'enforcement_mode');
-
-function getMode() {
-    try {
-        return fs.readFileSync(MODE_FILE, 'utf-8').trim();
-    } catch {
-        return 'guarded'; // Default
-    }
-}
-
-function checkGovernance(context) {
-    const mode = getMode();
-    const warnings = [];
-
-    // Check if governance is initialized
-    const policiesFile = path.join(process.cwd(), '.delimit', 'policies.yml');
-    if (!fs.existsSync(policiesFile)) {
-        warnings.push('No .delimit/policies.yml — run: delimit init');
-    }
-
-    // Check for sensitive file access
-    const sensitivePatterns = ['.env', 'credentials', '.ssh', 'secrets'];
-    const target = context.target || context.file || '';
-    for (const pattern of sensitivePatterns) {
-        if (target.includes(pattern)) {
-            if (mode === 'enforce') {
-                return { status: 'blocked', reason: `Access to sensitive path: ${target}` };
-            }
-            warnings.push(`Accessing sensitive path: ${target}`);
-        }
-    }
-
-    // Audit log
-    try {
-        const auditDir = path.join(DELIMIT_HOME, 'audit');
-        fs.mkdirSync(auditDir, { recursive: true });
-        const record = {
-            timestamp: new Date().toISOString(),
-            source: 'codex-skill',
-            mode,
-            context: typeof context === 'object' ? JSON.stringify(context).slice(0, 200) : String(context).slice(0, 200),
-            warnings,
-        };
-        const auditFile = path.join(auditDir, `${new Date().toISOString().split('T')[0]}.jsonl`);
-        fs.appendFileSync(auditFile, JSON.stringify(record) + '\n');
-    } catch {}
-
-    return { status: 'allowed', mode, warnings };
-}
-
-// Entry point — read context from stdin or args
-const context = process.argv[2] ? JSON.parse(process.argv[2]) : {};
-const result = checkGovernance(context);
-
-if (result.status === 'blocked') {
-    console.error(`[Delimit] BLOCKED: ${result.reason}`);
-    process.exit(1);
-}
-
-if (result.warnings.length > 0) {
-    for (const w of result.warnings) {
-        console.error(`[Delimit] Warning: ${w}`);
-    }
-}
-
-process.exit(0);

package/adapters/cursor-rules.js

@@ -1,73 +0,0 @@
-#!/usr/bin/env node
-/**
- * Delimit Governance Rules for Cursor
- *
- * Cursor doesn't have a hook system like Claude Code or Codex,
- * so governance enforcement happens server-side via MCP tool calls.
- * This adapter manages the .cursorrules and .cursor/rules/ files
- * that guide Cursor's behavior.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-// LED-213: Import canonical template for cross-model parity
-const { getDelimitSection } = require('../lib/delimit-template');
-
-const HOME = process.env.HOME || '';
-const CURSOR_DIR = path.join(HOME, '.cursor');
-const CURSOR_RULES_DIR = path.join(CURSOR_DIR, 'rules');
-const CURSORRULES_FILE = path.join(HOME, '.cursorrules');
-
-/**
- * Install Delimit governance rules into Cursor.
- * Creates both .cursorrules (legacy) and .cursor/rules/delimit.md (new).
- */
-function installRules(version) {
-    const rules = getDelimitRules(version);
-
-    // Install to .cursor/rules/delimit.md (new location, Cursor 0.45+)
-    if (fs.existsSync(CURSOR_DIR)) {
-        fs.mkdirSync(CURSOR_RULES_DIR, { recursive: true });
-        const rulesFile = path.join(CURSOR_RULES_DIR, 'delimit.md');
-        fs.writeFileSync(rulesFile, rules);
-    }
-
-    return { installed: true, paths: [CURSORRULES_FILE, path.join(CURSOR_RULES_DIR, 'delimit.md')] };
-}
-
-/**
- * Remove Delimit rules from Cursor.
- */
-function uninstallRules() {
-    const removed = [];
-
-    // Remove from .cursor/rules/
-    const rulesFile = path.join(CURSOR_RULES_DIR, 'delimit.md');
-    if (fs.existsSync(rulesFile)) {
-        fs.unlinkSync(rulesFile);
-        removed.push(rulesFile);
-    }
-
-    return { removed };
-}
-
-function getDelimitRules(version) {
-    // LED-213: Use canonical Consensus 123 template for Cursor parity
-    return getDelimitSection();
-}
-
-module.exports = { installRules, uninstallRules, getDelimitRules };
-
-// CLI entry point
-if (require.main === module) {
-    const action = process.argv[2] || 'install';
-    const version = process.argv[3] || '3.11.9';
-    if (action === 'install') {
-        const result = installRules(version);
-        console.log(`Installed Delimit rules to Cursor: ${result.paths.join(', ')}`);
-    } else if (action === 'uninstall') {
-        const result = uninstallRules();
-        console.log(`Removed: ${result.removed.join(', ') || 'nothing to remove'}`);
-    }
-}