greprag 5.77.0 → 5.78.0

package/dist/commands/app-model.js

@@ -0,0 +1,308 @@
+"use strict";
+/** Read model for the local GrepRAG customer app.
+ * adr: adr/local-app-control-plane.md
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverLocalProjects = discoverLocalProjects;
+exports.buildAppModel = buildAppModel;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const app_settings_1 = require("../app-settings");
+const project_anchor_1 = require("../project-anchor");
+const native_skill_mirror_1 = require("../native-skill-mirror");
+const status_1 = require("./status");
+const config_1 = require("./config");
+const reminder_registry_1 = require("./reminder-registry");
+const reminder_injector_1 = require("../reminder-injector");
+const INTERNAL_STORE_KINDS = new Set([
+    'memory', 'inbox', 'fix', 'docptr', 'skillgain', 'skill', 'parity', 'doctrine',
+]);
+const INTERRUPT_COPY = {
+    'os-primer': { label: 'Operating guidance', description: 'Teaches agents GrepRAG’s recovery and coordination rules.', group: 'Core guidance' },
+    'inbox-primer': { label: 'Inbox guidance', description: 'Explains live cross-agent messages and watcher setup.', group: 'Communication' },
+    'load-primer': { label: 'Feature discovery', description: 'Shows agents how to load GrepRAG capabilities on demand.', group: 'Core guidance' },
+    'chip-spawn-pointer': { label: 'Claude delegation', description: 'Guides Claude Code when work should move to another task.', group: 'Delegation' },
+    'codex-chip-spawn-pointer': { label: 'Codex delegation', description: 'Guides Codex when work should move to another task.', group: 'Delegation' },
+    'email-primer': { label: 'Agent email', description: 'Explains real email separately from internal agent messages.', group: 'Communication' },
+    'corpus-announce': { label: 'Knowledge reminders', description: 'Points agents to relevant reference collections.', group: 'Knowledge' },
+    'doc-pointer-announce': { label: 'Project documents', description: 'Shows the project’s core reference documents at startup.', group: 'Knowledge' },
+    'skill-gain-announce': { label: 'Skill improvements', description: 'Surfaces newly learned improvements for installed skills.', group: 'Skills' },
+    'skill-mirror-announce': { label: 'Available skills', description: 'Makes mirrored skills discoverable to each agent.', group: 'Skills' },
+    'procedure-announce': { label: 'Saved procedures', description: 'Reminds agents about active project procedures.', group: 'Automation' },
+    'delivery-control': { label: 'Delivery guidance', description: 'Keeps code delivery and production verification consistent.', group: 'Automation' },
+    'persona-announce': { label: 'Speaking style', description: 'Applies the selected GrepRAG persona across agents.', group: 'Personalization' },
+    'loadout-registrar': { label: 'Equipped loadouts', description: 'Makes equipped skill collections available when relevant.', group: 'Skills' },
+    'setup-warning': { label: 'Setup warnings', description: 'Calls out missing configuration that prevents GrepRAG from working.', group: 'Health' },
+    'version-upgrade': { label: 'Update notices', description: 'Warns when the installed CLI is behind the current release.', group: 'Health' },
+    'enrichment-health': { label: 'Knowledge health', description: 'Warns when knowledge enrichment is unavailable.', group: 'Health' },
+    'assistant-doctrine': { label: 'Assistant role', description: 'Loads the executive-assistant behavior for its assigned project.', group: 'Roles' },
+    'memory-primer': { label: 'Memory guidance', description: 'Teaches agents how and when to retrieve project memory.', group: 'Memory' },
+    'watcher-arm': { label: 'Live inbox checks', description: 'Reminds Claude Code to keep live message delivery connected.', group: 'Communication' },
+    'mechanic-friction': { label: 'Automatic repair prompts', description: 'Surfaces repeated harness friction for durable repair.', group: 'Automation' },
+    collision: { label: 'Collision warnings', description: 'Warns before shared Git actions when another session is active.', group: 'Delegation' },
+};
+function readObject(file) {
+    try {
+        const value = JSON.parse(fs.readFileSync(file, 'utf8'));
+        return value && typeof value === 'object' && !Array.isArray(value)
+            ? value
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function countDirectories(root) {
+    let names = [];
+    try {
+        names = fs.readdirSync(root, { withFileTypes: true })
+            .filter(entry => entry.isDirectory() && !entry.name.startsWith('.'))
+            .map(entry => entry.name)
+            .sort();
+    }
+    catch { /* missing root */ }
+    const state = readObject(path.join(root, '.greprag-mirror.json'));
+    const skills = state.skills && typeof state.skills === 'object' && !Array.isArray(state.skills)
+        ? state.skills
+        : {};
+    return { count: names.length, names, managed: Object.keys(skills).length };
+}
+function discoverLocalProjects(cwd, homeDir = os.homedir()) {
+    const candidates = [path.resolve(cwd)];
+    const registry = readObject(path.join(homeDir, '.greprag', 'projects.json'));
+    for (const value of Object.values(registry)) {
+        if (typeof value === 'string' && value.trim())
+            candidates.push(path.resolve(value));
+    }
+    const byId = new Map();
+    for (const candidate of [...new Set(candidates)]) {
+        if (!fs.existsSync(candidate))
+            continue;
+        try {
+            const anchor = (0, project_anchor_1.readAnchor)(candidate);
+            if (!byId.has(anchor.projectId)) {
+                byId.set(anchor.projectId, {
+                    id: anchor.projectId,
+                    name: anchor.projectName,
+                    path: candidate,
+                    initialized: anchor.initialized,
+                });
+            }
+        }
+        catch { /* an unreadable registered path should not break the app */ }
+    }
+    return [...byId.values()];
+}
+function asRefresh(store) {
+    const metadata = store.metadata;
+    if (!metadata || typeof metadata !== 'object')
+        return null;
+    const refresh = metadata.refresh;
+    return refresh && typeof refresh === 'object' && !Array.isArray(refresh)
+        ? refresh
+        : null;
+}
+function corpusStoreView(store) {
+    const refresh = asRefresh(store);
+    const failures = typeof refresh?.consecutiveFailures === 'number'
+        ? refresh.consecutiveFailures
+        : 0;
+    const policy = typeof refresh?.policy === 'string' ? refresh.policy : 'off';
+    const hasSource = typeof refresh?.url === 'string' && refresh.url.length > 0;
+    return {
+        id: store.id,
+        name: store.name,
+        kind: store.kind,
+        tags: store.tags || [],
+        nodes: store.nodeCount || 0,
+        words: store.wordCount || 0,
+        policy: hasSource ? policy : 'frozen',
+        lastCheckedAt: typeof refresh?.lastFetchedAt === 'string'
+            ? refresh.lastFetchedAt
+            : store.updatedAt || store.createdAt,
+        nextCheckAt: typeof refresh?.nextCheckAt === 'string' ? refresh.nextCheckAt : null,
+        failures,
+        health: failures > 0 ? 'attention' : 'healthy',
+    };
+}
+async function fetchJson(url, apiKey) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 7_000);
+    try {
+        const response = await fetch(url, {
+            headers: { Authorization: `Bearer ${apiKey}` },
+            signal: controller.signal,
+        });
+        if (!response.ok)
+            throw new Error(`HTTP ${response.status}`);
+        return response.json();
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function readCloud(apiUrl, apiKey) {
+    if (!apiKey)
+        return { status: 'unconfigured', stores: [], skills: [], projects: [], error: null };
+    const [storesResult, skillsResult, projectsResult] = await Promise.allSettled([
+        fetchJson(`${apiUrl}/v1/stores`, apiKey),
+        fetchJson(`${apiUrl}/v1/skillmirror`, apiKey),
+        fetchJson(`${apiUrl}/v1/projects/discover`, apiKey),
+    ]);
+    const stores = storesResult.status === 'fulfilled' ? storesResult.value.stores || [] : [];
+    const skills = skillsResult.status === 'fulfilled' ? skillsResult.value.skills || [] : [];
+    const projects = projectsResult.status === 'fulfilled' ? projectsResult.value.projects || [] : [];
+    const errors = [storesResult, skillsResult, projectsResult]
+        .filter((result) => result.status === 'rejected')
+        .map(result => result.reason instanceof Error ? result.reason.message : String(result.reason));
+    return {
+        status: errors.length === 3 ? 'offline' : errors.length ? 'partial' : 'connected',
+        stores,
+        skills,
+        projects,
+        error: errors.length ? errors.join('; ') : null,
+    };
+}
+function platformLabel(key) {
+    return ({ claude: 'Claude Code', codex: 'Codex', opencode: 'OpenCode', grok: 'Grok Build' })[key];
+}
+function platformSkillRoots(key, projectPath, homeDir) {
+    if (key === 'grok')
+        return [path.join(homeDir, '.grok', 'skills')];
+    const native = key === 'claude' ? 'claude-code' : key;
+    return [(0, native_skill_mirror_1.nativeSkillRoot)(native, homeDir), (0, native_skill_mirror_1.nativeProjectSkillRoot)(native, projectPath)];
+}
+async function buildAppModel(cwd, requestedProjectId, homeDir = os.homedir()) {
+    const projects = discoverLocalProjects(cwd, homeDir);
+    const selected = projects.find(project => project.id === requestedProjectId) || projects[0];
+    const selectedPath = selected?.path || path.resolve(cwd);
+    const status = (0, status_1.buildStatus)(selectedPath);
+    const config = (0, config_1.getConfig)();
+    const cloud = await readCloud(config.apiUrl, config.apiKey);
+    const localSettings = (0, app_settings_1.readLocalAppSettings)(homeDir);
+    const disabled = new Set(localSettings.interrupts.disabled);
+    const platforms = Object.keys(status.platforms).map(key => {
+        const roots = platformSkillRoots(key, selectedPath, homeDir).map(countDirectories);
+        const names = [...new Set(roots.flatMap(root => root.names))].sort();
+        return {
+            id: key,
+            label: platformLabel(key),
+            configured: status.platforms[key].configured,
+            installed: status.platforms[key].config_present,
+            skillCount: names.length,
+            managedSkillCount: roots.reduce((sum, root) => sum + root.managed, 0),
+            skills: names,
+            note: status.platforms[key].note || '',
+            canToggleSkillAdapter: key === 'codex' || key === 'opencode',
+        };
+    });
+    const corpusStores = cloud.stores.filter(store => !INTERNAL_STORE_KINDS.has(store.kind)).map(corpusStoreView);
+    const projectMemory = cloud.projects.find(project => project.id === selected?.id);
+    const memoryRows = projectMemory
+        ? Object.values(projectMemory.row_counts || {}).reduce((sum, count) => sum + count, 0)
+        : 0;
+    const corpusFailures = corpusStores.reduce((sum, store) => sum + store.failures, 0);
+    const configuredAgents = platforms.filter(platform => platform.configured).length;
+    const issues = [];
+    if (!status.auth.api_key_present)
+        issues.push('Connect a GrepRAG account to enable cloud memory and knowledge.');
+    if (configuredAgents === 0)
+        issues.push('No agent integration is fully connected.');
+    if (status.windows_shims?.mismatch)
+        issues.push('An older GrepRAG command is still active on this machine.');
+    if (cloud.status === 'offline')
+        issues.push('Cloud metrics are unavailable right now. Local settings still work.');
+    if (corpusFailures > 0)
+        issues.push(`${corpusFailures} knowledge refresh failure${corpusFailures === 1 ? '' : 's'} need attention.`);
+    return {
+        app: { version: status.version, cwd: path.resolve(cwd) },
+        account: {
+            connected: status.auth.api_key_present,
+            handle: status.identity.handle,
+            tenantId: status.identity.tenant_id,
+            cloudStatus: cloud.status,
+            cloudError: cloud.error,
+        },
+        health: { state: issues.length ? 'attention' : 'healthy', issues },
+        projects,
+        selectedProject: selected ? {
+            ...selected,
+            settings: (0, app_settings_1.readProjectAppSettings)(selectedPath),
+        } : null,
+        agents: platforms,
+        memory: {
+            nodes: memoryRows,
+            stores: projectMemory ? 1 : 0,
+            firstActivity: projectMemory?.first_activity || null,
+            lastActivity: projectMemory?.last_activity || null,
+            captureEnabled: status.project.memory_capture,
+            recapEnabled: status.project.session_start_recap,
+        },
+        skills: {
+            mirrored: cloud.skills.length,
+            installedUnique: new Set(platforms.flatMap(platform => platform.skills)).size,
+            adaptersActive: platforms.filter(platform => platform.managedSkillCount > 0).length,
+        },
+        corpus: {
+            status: cloud.status,
+            stores: corpusStores,
+            count: corpusStores.length,
+            nodes: corpusStores.reduce((sum, store) => sum + store.nodes, 0),
+            words: corpusStores.reduce((sum, store) => sum + store.words, 0),
+            failures: corpusFailures,
+        },
+        notifications: {
+            modules: reminder_registry_1.REGISTRY.map(module => ({
+                id: module.id,
+                ...(INTERRUPT_COPY[module.id] || {
+                    label: module.id,
+                    description: 'Controls this GrepRAG startup or just-in-time guidance.',
+                    group: 'Other',
+                }),
+                enabled: !disabled.has(module.id),
+                surface: module.source === 'command' ? 'Before sensitive actions' : 'Agent guidance',
+                harnesses: module.harnesses || ['claude-code', 'codex', 'opencode', 'grok'],
+            })),
+        },
+        advanced: {
+            mechanicEnabled: !(0, reminder_injector_1.mechanicKilled)(),
+            settingsPath: path.join(homeDir, '.greprag', 'settings.json'),
+            projectSettingsPath: status.project.anchor_path,
+            apiUrl: config.apiUrl,
+        },
+    };
+}

package/dist/commands/app.js

@@ -0,0 +1,310 @@
+"use strict";
+/** `greprag` local customer app launcher and loopback server.
+ * adr: adr/local-app-control-plane.md
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.browserLaunchCommand = browserLaunchCommand;
+exports.openDefaultBrowser = openDefaultBrowser;
+exports.startAppServer = startAppServer;
+exports.runApp = runApp;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const http = __importStar(require("node:http"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const app_model_1 = require("./app-model");
+const app_settings_1 = require("../app-settings");
+const reminder_registry_1 = require("./reminder-registry");
+const config_1 = require("./config");
+const native_skill_mirror_1 = require("../native-skill-mirror");
+const LOOPBACK = '127.0.0.1';
+const BODY_LIMIT = 64 * 1024;
+function appAssetRoot() {
+    return path.join(__dirname, '..', '..', 'app');
+}
+function mimeType(file) {
+    if (file.endsWith('.html'))
+        return 'text/html; charset=utf-8';
+    if (file.endsWith('.css'))
+        return 'text/css; charset=utf-8';
+    if (file.endsWith('.js'))
+        return 'text/javascript; charset=utf-8';
+    if (file.endsWith('.svg'))
+        return 'image/svg+xml';
+    return 'application/octet-stream';
+}
+function sendJson(res, status, body) {
+    const payload = JSON.stringify(body);
+    res.writeHead(status, {
+        'Content-Type': 'application/json; charset=utf-8',
+        'Content-Length': Buffer.byteLength(payload),
+        'Cache-Control': 'no-store',
+    });
+    res.end(payload);
+}
+function safeEqual(a, b) {
+    const left = Buffer.from(a);
+    const right = Buffer.from(b);
+    return left.length === right.length && crypto.timingSafeEqual(left, right);
+}
+function cookieValue(req, name) {
+    for (const part of String(req.headers.cookie || '').split(';')) {
+        const [key, ...value] = part.trim().split('=');
+        if (key === name)
+            return decodeURIComponent(value.join('='));
+    }
+    return null;
+}
+async function readBody(req) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.length;
+        if (size > BODY_LIMIT)
+            throw new Error('Request is too large.');
+        chunks.push(buffer);
+    }
+    const raw = Buffer.concat(chunks).toString('utf8');
+    if (!raw)
+        return {};
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        throw new Error('Expected a JSON object.');
+    return parsed;
+}
+function resolveProject(cwd, projectId) {
+    if (typeof projectId !== 'string')
+        throw new Error('Project id is required.');
+    const project = (0, app_model_1.discoverLocalProjects)(cwd).find(candidate => candidate.id === projectId);
+    if (!project)
+        throw new Error('That project is not registered on this machine.');
+    return project.path;
+}
+function projectPatch(body) {
+    const allowed = new Set([
+        'memoryCapture', 'sessionStartRecap', 'inboxNotify', 'crushWrap',
+        'contextGovernor', 'contextThreshold', 'pngArchive', 'emailAutosave',
+    ]);
+    const patch = body.patch;
+    if (!patch || typeof patch !== 'object' || Array.isArray(patch))
+        throw new Error('Settings patch is required.');
+    for (const key of Object.keys(patch))
+        if (!allowed.has(key))
+            throw new Error(`Unknown setting: ${key}`);
+    return patch;
+}
+async function setAdapter(body, cwd) {
+    const platform = body.platform;
+    if (platform !== 'codex' && platform !== 'opencode')
+        throw new Error('Only Codex and OpenCode use optional skill adapters.');
+    if (typeof body.enabled !== 'boolean')
+        throw new Error('enabled must be true or false.');
+    const projectDir = resolveProject(cwd, body.projectId);
+    const project = (0, app_model_1.discoverLocalProjects)(cwd).find(candidate => candidate.path === projectDir);
+    const nativePlatform = platform;
+    if (!body.enabled) {
+        return (0, native_skill_mirror_1.applyNativeSkillMirror)({
+            platform: nativePlatform,
+            skills: [],
+            projectDir,
+            prune: true,
+        });
+    }
+    const config = (0, config_1.getConfig)();
+    if (!config.apiKey)
+        throw new Error('Connect GrepRAG before enabling skill adapters.');
+    return (0, native_skill_mirror_1.syncNativeSkillMirror)({
+        platform: nativePlatform,
+        apiUrl: config.apiUrl,
+        apiKey: config.apiKey,
+        projectId: project.id,
+        projectDir,
+    });
+}
+function browserLaunchCommand(url, platform = process.platform) {
+    if (platform === 'win32')
+        return { command: 'rundll32.exe', args: ['url.dll,FileProtocolHandler', url] };
+    if (platform === 'darwin')
+        return { command: 'open', args: [url] };
+    return { command: 'xdg-open', args: [url] };
+}
+function openDefaultBrowser(url) {
+    const launch = browserLaunchCommand(url);
+    const child = (0, node_child_process_1.spawn)(launch.command, launch.args, { detached: true, stdio: 'ignore', windowsHide: true });
+    child.unref();
+}
+async function startAppServer(options = {}) {
+    const cwd = path.resolve(options.cwd || process.cwd());
+    const token = crypto.randomBytes(24).toString('base64url');
+    const idleTimeoutMs = options.idleTimeoutMs === undefined ? 90_000 : options.idleTimeoutMs;
+    const startedAt = Date.now();
+    let lastHeartbeat = Date.now();
+    let authenticatedOnce = false;
+    let origin = '';
+    const server = http.createServer(async (req, res) => {
+        try {
+            const requestUrl = new URL(req.url || '/', origin || `http://${LOOPBACK}`);
+            if (requestUrl.pathname === '/health')
+                return sendJson(res, 200, { ok: true });
+            const queryToken = requestUrl.searchParams.get('token');
+            if (requestUrl.pathname === '/' && queryToken && safeEqual(queryToken, token)) {
+                authenticatedOnce = true;
+                lastHeartbeat = Date.now();
+                res.writeHead(303, {
+                    Location: '/',
+                    'Set-Cookie': `greprag_session=${encodeURIComponent(token)}; HttpOnly; SameSite=Strict; Path=/`,
+                    'Cache-Control': 'no-store',
+                });
+                res.end();
+                return;
+            }
+            const authenticated = safeEqual(cookieValue(req, 'greprag_session') || '', token);
+            if (!authenticated)
+                return sendJson(res, 401, { ok: false, error: 'Open GrepRAG from the CLI again.' });
+            lastHeartbeat = Date.now();
+            if (req.method !== 'GET' && req.headers.origin !== origin) {
+                return sendJson(res, 403, { ok: false, error: 'Request origin was rejected.' });
+            }
+            if (requestUrl.pathname === '/api/heartbeat' && req.method === 'POST') {
+                return sendJson(res, 200, { ok: true });
+            }
+            if (requestUrl.pathname === '/api/model' && req.method === 'GET') {
+                const model = await (0, app_model_1.buildAppModel)(cwd, requestUrl.searchParams.get('project') || undefined);
+                return sendJson(res, 200, { ok: true, model });
+            }
+            if (requestUrl.pathname === '/api/project-settings' && req.method === 'PATCH') {
+                const body = await readBody(req);
+                const projectDir = resolveProject(cwd, body.projectId);
+                const settings = (0, app_settings_1.updateProjectAppSettings)(projectDir, projectPatch(body));
+                return sendJson(res, 200, { ok: true, settings });
+            }
+            if (requestUrl.pathname === '/api/interrupts' && req.method === 'PATCH') {
+                const body = await readBody(req);
+                if (typeof body.id !== 'string' || !reminder_registry_1.REGISTRY.some(module => module.id === body.id)) {
+                    throw new Error('Unknown guidance feature.');
+                }
+                if (typeof body.enabled !== 'boolean')
+                    throw new Error('enabled must be true or false.');
+                const settings = (0, app_settings_1.setInterruptEnabled)(body.id, body.enabled);
+                return sendJson(res, 200, { ok: true, settings });
+            }
+            if (requestUrl.pathname === '/api/skill-adapter' && req.method === 'POST') {
+                const body = await readBody(req);
+                const result = await setAdapter(body, cwd);
+                return sendJson(res, 200, { ok: true, result });
+            }
+            const assetName = requestUrl.pathname === '/' ? 'index.html' : requestUrl.pathname.slice(1);
+            if (!/^[a-zA-Z0-9._-]+$/.test(assetName))
+                return sendJson(res, 404, { ok: false, error: 'Not found.' });
+            const file = path.join(appAssetRoot(), assetName);
+            if (!fs.existsSync(file) || !fs.statSync(file).isFile())
+                return sendJson(res, 404, { ok: false, error: 'Not found.' });
+            const payload = fs.readFileSync(file);
+            res.writeHead(200, {
+                'Content-Type': mimeType(file),
+                'Content-Length': payload.length,
+                'Cache-Control': assetName === 'index.html' ? 'no-store' : 'private, max-age=300',
+                'Content-Security-Policy': "default-src 'self'; script-src 'self'; style-src 'self'; img-src 'self' data:; connect-src 'self'; frame-ancestors 'none'; base-uri 'none'",
+                'X-Content-Type-Options': 'nosniff',
+                'Referrer-Policy': 'no-referrer',
+            });
+            res.end(payload);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Request failed.';
+            sendJson(res, 400, { ok: false, error: message });
+        }
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(options.port || 0, LOOPBACK, () => resolve());
+    });
+    const address = server.address();
+    if (!address || typeof address === 'string')
+        throw new Error('Could not resolve the local app port.');
+    origin = `http://${LOOPBACK}:${address.port}`;
+    const idleTimer = idleTimeoutMs > 0 ? setInterval(() => {
+        const idle = Date.now() - lastHeartbeat > idleTimeoutMs;
+        const neverOpened = !authenticatedOnce && Date.now() - startedAt > Math.max(idleTimeoutMs, 300_000);
+        if ((authenticatedOnce && idle) || neverOpened)
+            server.close();
+    }, Math.min(15_000, Math.max(1_000, Math.floor(idleTimeoutMs / 3)))) : null;
+    idleTimer?.unref();
+    const close = async () => {
+        if (idleTimer)
+            clearInterval(idleTimer);
+        if (!server.listening)
+            return;
+        await new Promise(resolve => server.close(() => resolve()));
+    };
+    const launchUrl = `${origin}/?token=${encodeURIComponent(token)}`;
+    if (options.openBrowser !== false)
+        openDefaultBrowser(launchUrl);
+    return { url: origin, launchUrl, token, close };
+}
+function flagValue(args, flag) {
+    const index = args.indexOf(flag);
+    return index >= 0 ? args[index + 1] : undefined;
+}
+async function runApp(args = []) {
+    if (args.includes('--help') || args.includes('-h') || args.includes('help')) {
+        console.log(`greprag — open the local GrepRAG app\n\n  greprag\n  greprag app [--port <number>] [--no-open]\n  greprag dashboard [--port <number>] [--no-open]\n\nThe app binds only to 127.0.0.1 and stops after the browser disconnects.`);
+        return;
+    }
+    const portRaw = flagValue(args, '--port');
+    const port = portRaw === undefined ? 0 : Number(portRaw);
+    if (!Number.isInteger(port) || port < 0 || port > 65_535)
+        throw new Error('--port must be an integer from 0 to 65535.');
+    const openBrowser = !args.includes('--no-open');
+    const running = await startAppServer({ port, openBrowser });
+    console.log(`GrepRAG is open at ${running.url}`);
+    if (!openBrowser)
+        console.log(`Open this one-time link: ${running.launchUrl}`);
+    console.log('Keep this window open while using the app. It closes automatically after the browser disconnects.');
+    await new Promise(resolve => {
+        const stop = () => { void running.close().then(resolve); };
+        process.once('SIGINT', stop);
+        process.once('SIGTERM', stop);
+        const poll = setInterval(() => {
+            fetch(`${running.url}/health`).catch(() => {
+                clearInterval(poll);
+                resolve();
+            });
+        }, 2_000);
+        poll.unref();
+    });
+}

package/dist/commands/opencode-interrupt.js

@@ -6,6 +6,7 @@ exports.getOpenCodeAnnounces = getOpenCodeAnnounces;
 exports.getOpenCodePersistentAnnounces = getOpenCodePersistentAnnounces;
 exports.getOpenCodeReminders = getOpenCodeReminders;
 const reminder_registry_1 = require("./reminder-registry");
+const app_settings_1 = require("../app-settings");
 /** The opencode registry is DERIVED from the canon, never hand-whitelisted.
  *  Every REGISTRY module ships to opencode unless it declares a `harnesses`
  *  list excluding it (reminder-types.ts) — so a new module wired into
@@ -49,14 +50,14 @@ function buildOpenCodeEnv(params) {
     };
 }
 function getOpenCodeAnnounces(env) {
-    return [...(0, reminder_registry_1.collectAnnounces)(env, exports.opencodeRegistry), exports.OPENCODE_QUOTA_WAITLIST_ANNOUNCE];
+    return [...(0, reminder_registry_1.collectAnnounces)(env, (0, app_settings_1.filterEnabledInterrupts)(exports.opencodeRegistry)), exports.OPENCODE_QUOTA_WAITLIST_ANNOUNCE];
 }
 /** OpenCode rebuilds output.system for every model call. Persona is the one
  *  startup primer that must remain behaviorally active on later calls, so the
  *  plugin replays this shared-registry module from its bounded session cache. */
 function getOpenCodePersistentAnnounces(env) {
-    return (0, reminder_registry_1.collectAnnounces)(env, exports.opencodeRegistry.filter((m) => m.id === 'persona-announce'));
+    return (0, reminder_registry_1.collectAnnounces)(env, (0, app_settings_1.filterEnabledInterrupts)(exports.opencodeRegistry.filter((m) => m.id === 'persona-announce')));
 }
 function getOpenCodeReminders(env) {
-    return (0, reminder_registry_1.collectReminders)(env, exports.opencodeRegistry);
+    return (0, reminder_registry_1.collectReminders)(env, (0, app_settings_1.filterEnabledInterrupts)(exports.opencodeRegistry));
 }

package/dist/hook.js

@@ -83,6 +83,7 @@ const guard_1 = require("./guard");
 // auto-silences when resolved (the arm-check pattern). The hook below assembles the
 // live env (ALL I/O) and emits; the modules are pure.
 const reminder_registry_1 = require("./commands/reminder-registry");
+const app_settings_1 = require("./app-settings");
 const inbox_primer_reminder_1 = require("./commands/inbox-primer-reminder");
 const skill_activation_manifest_1 = require("./skill-activation-manifest");
 const worktree_state_1 = require("./worktree-state");
@@ -1728,7 +1729,9 @@ async function recap(input, mode = 'plain', opts = {}) {
         activeCommandDrift: activeCommandDrift(),
         loadoutUpdateRequired,
     };
-    let announceReg = (0, reminder_injector_1.mechanicKilled)() ? reminder_registry_1.REGISTRY.filter(m => m.id !== 'mechanic-friction') : reminder_registry_1.REGISTRY;
+    let announceReg = (0, app_settings_1.filterEnabledInterrupts)(reminder_registry_1.REGISTRY);
+    if ((0, reminder_injector_1.mechanicKilled)())
+        announceReg = announceReg.filter(m => m.id !== 'mechanic-friction');
     if (!announceShort)
         announceReg = announceReg.filter(m => m.id !== 'watcher-arm');
     // PostCompact: a compaction wiped the once-loaded SessionStart announces from context.
@@ -2211,7 +2214,7 @@ async function coordinateGate(input) {
         toolCommand: typeof toolInput.command === 'string' ? toolInput.command : '',
         collisionPeers: peers,
     };
-    const fired = (0, reminder_registry_1.collectReminders)(env, (0, reminder_registry_1.commandModules)());
+    const fired = (0, reminder_registry_1.collectReminders)(env, (0, app_settings_1.filterEnabledInterrupts)((0, reminder_registry_1.commandModules)()));
     if (!fired.length)
         return;
     // Effect: inject as additionalContext — advisory heads-up, NO permission pause.