greprag 5.76.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/codex-doctor.js

@@ -113,5 +113,6 @@ async function doctorCodex(args, deps) {
     console.log(`    PermissionRequest ctx:    ${hasHook(hooks, 'PermissionRequest', 'codex-permission-context') ? 'yes' : 'no'}`);
     console.log(`    SubagentStart metadata:   ${hasHook(hooks, 'SubagentStart', 'codex-subagent-start') ? 'yes' : 'no'}`);
     console.log(`    Stop store:               ${hasHook(hooks, 'Stop', 'codex-store') ? 'yes' : 'no'}`);
+    console.log(`    PostCompact re-announce:  ${hasHook(hooks, 'PostCompact', 'recompact') ? 'yes' : 'no'}`);
     console.log(`    PostCompact session-id:   ${hasHook(hooks, 'PostCompact', 'session-id') ? 'yes' : 'no'}`);
 }

package/dist/commands/delivery-reminder.js

@@ -12,15 +12,15 @@ exports.buildDeliveryAnnounce = buildDeliveryAnnounce;
 // adr: adr/delivery-announce-pilot.md
 function coordinationLine(platform) {
     if (platform === 'codex') {
-        return 'Codex: at the merge/deploy gate, call codex_app.list_threads unfiltered, filter to peers in the same repo, then use codex_app.send_message_to_thread once for ready or overlapping work. Delivery owner: rename this task `DEPLOY: <existing title>`; transfer the prefix on handoff; remove the prefix when delivery is done.';
+        return 'Codex: at the merge/deploy gate, call codex_app.list_threads unfiltered, filter to peers in the same repo, and inspect their current summaries/status. Use codex_app.send_message_to_thread only for visible evidence of an unlanded ready commit, overlapping integration, or a concrete blocker. Peers with nothing actionable stay silent; do not solicit or send negative acknowledgements or routine completion follow-ups. Delivery owner: rename this task `DEPLOY: <existing title>` for operator visibility only; transfer the prefix on handoff; remove it before reporting delivery complete or abandoned.';
     }
     if (platform === 'claude-code') {
-        return 'Claude Code: at the merge/deploy gate, discover peers in the same repo and send one concise delivery notice to peers with ready or overlapping work.';
+        return 'Claude Code: at the merge/deploy gate, inspect peers in the same repo and send one concise delivery notice only for visible evidence of an unlanded ready commit, overlapping integration, or a concrete blocker. Peers with nothing actionable stay silent; do not solicit or send negative acknowledgements or routine completion follow-ups.';
     }
     if (platform === 'opencode') {
-        return 'OpenCode: at the merge/deploy gate, use the GrepRAG project/session registry and send one concise delivery notice to peers with ready or overlapping work.';
+        return 'OpenCode: at the merge/deploy gate, use the GrepRAG project/session registry and send one concise notice only for visible evidence of an unlanded ready commit, overlapping integration, or a concrete blocker. Peers with nothing actionable stay silent; do not solicit or send negative acknowledgements or routine completion follow-ups.';
     }
-    return 'At the merge/deploy gate, coordinate once with peers in the same repo who have ready or overlapping work.';
+    return 'At the merge/deploy gate, inspect peers in the same repo and send one concise notice only for visible evidence of an unlanded ready commit, overlapping integration, or a concrete blocker. Peers with nothing actionable stay silent; do not solicit or send negative acknowledgements or routine completion follow-ups.';
 }
 function buildDeliveryAnnounce(env) {
     if (!env.deliveryRepo)
@@ -30,7 +30,7 @@ function buildDeliveryAnnounce(env) {
         `[DELIVERY — ${project}]`,
         'Commit useful, passing work.',
         coordinationLine(env.platform),
-        'Include ready peer commits and clear known blockers, then merge to the default branch and deploy immediately. Missing replies and unfinished peer work do not block delivery.',
+        'Include visible ready peer commits and clear known blockers, then merge to the default branch and deploy immediately. Silence means nothing actionable and does not block delivery.',
         'Use this repo\'s delivery profile and verify production.',
     ].join('\n');
 }