0xray 3.5.4 → 3.5.5

package/dist/nucleus/user-aside.js

@@ -0,0 +1,393 @@
+/**
+ * User aside — parallel work tracks (worktree-like) declared by the user.
+ * SSOT: `.xray/state/asides/{id}.json` + `_active.json`.
+ * Todo ids: `{asideId}.a.{phase}.{todo}` — globally unique per aside.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { buildLeadDevPlan, isLeadDevModeActive, } from './autonomy-kernel.js';
+import { allPlanTodos, getNextRequiredTodo, getOutstandingTodos, } from './lead-dev-plan-persistence.js';
+export const USER_ASIDE_ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/;
+/** Namespaced aside todo: `suit-nft.a.1.1` */
+export const USER_ASIDE_TODO_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}\.a\.\d+\.\d+$/;
+export const USER_ASIDE_STATE_VERSION = 1;
+export class UserAsideValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'UserAsideValidationError';
+    }
+}
+export function assertSafeAsideId(asideId) {
+    const trimmed = asideId.trim();
+    if (!trimmed || !USER_ASIDE_ID_PATTERN.test(trimmed)) {
+        throw new UserAsideValidationError(`Invalid aside id "${asideId}" — use [a-zA-Z0-9][a-zA-Z0-9._-]{0,63}`);
+    }
+    if (trimmed.includes('..') || trimmed.includes('/') || trimmed.includes('\\')) {
+        throw new UserAsideValidationError(`Invalid aside id "${asideId}" — path characters forbidden`);
+    }
+    return trimmed;
+}
+export function asideTodoId(asideId, phaseIndex, todoIndex) {
+    return `${assertSafeAsideId(asideId)}.a.${phaseIndex + 1}.${todoIndex + 1}`;
+}
+export function isUserAsideTodoId(todoId) {
+    return USER_ASIDE_TODO_PATTERN.test(todoId);
+}
+export function parseAsideIdFromTodoId(todoId) {
+    if (!isUserAsideTodoId(todoId))
+        return null;
+    const dotA = todoId.indexOf('.a.');
+    if (dotA <= 0)
+        return null;
+    const asideId = todoId.slice(0, dotA);
+    try {
+        return assertSafeAsideId(asideId);
+    }
+    catch {
+        return null;
+    }
+}
+export function userAsidesDir(projectRoot = process.cwd()) {
+    return path.join(projectRoot, '.xray', 'state', 'asides');
+}
+export function userAsidePath(asideId, projectRoot = process.cwd()) {
+    const safe = assertSafeAsideId(asideId);
+    const resolved = path.resolve(userAsidesDir(projectRoot), `${safe}.json`);
+    const base = path.resolve(userAsidesDir(projectRoot));
+    if (!resolved.startsWith(base + path.sep) && resolved !== base) {
+        throw new UserAsideValidationError(`Aside path escapes asides directory: ${asideId}`);
+    }
+    return resolved;
+}
+export function activeAsidePointerPath(projectRoot = process.cwd()) {
+    return path.join(userAsidesDir(projectRoot), '_active.json');
+}
+export function isUserAsidesEnabled(projectRoot = process.cwd()) {
+    const featuresPath = path.join(projectRoot, '.xray', 'features.json');
+    if (!fs.existsSync(featuresPath))
+        return isLeadDevModeActive();
+    try {
+        const data = JSON.parse(fs.readFileSync(featuresPath, 'utf8'));
+        const raw = data.multi_agent_orchestration?.user_asides;
+        if (raw?.enabled === false)
+            return false;
+        return isLeadDevModeActive();
+    }
+    catch {
+        return isLeadDevModeActive();
+    }
+}
+function validateLoadedAside(parsed, expectedId) {
+    if (!parsed || typeof parsed !== 'object')
+        return null;
+    const row = parsed;
+    if (row.version !== USER_ASIDE_STATE_VERSION)
+        return null;
+    if (!row.id || !row.title || !row.description || !row.plan)
+        return null;
+    if (!Array.isArray(row.plan.phases))
+        return null;
+    try {
+        assertSafeAsideId(row.id);
+    }
+    catch {
+        return null;
+    }
+    if (expectedId && row.id !== expectedId)
+        return null;
+    for (const phase of row.plan.phases) {
+        if (!phase?.todos || !Array.isArray(phase.todos))
+            return null;
+    }
+    return row;
+}
+function remapPhasesToAsidePrefix(asideId, phases) {
+    const safeId = assertSafeAsideId(asideId);
+    return phases.map((phase, phaseIndex) => ({
+        ...phase,
+        id: phase.id.startsWith('phase-') ? `aside-phase-${phaseIndex + 1}` : phase.id,
+        todos: phase.todos.map((todo, todoIndex) => ({
+            ...todo,
+            id: asideTodoId(safeId, phaseIndex, todoIndex),
+            status: todo.status ?? 'pending',
+        })),
+    }));
+}
+/** Build a phased aside plan from task intake (mirrors lead-dev plan, namespaced todo ids). */
+export function buildUserAsidePlan(asideId, title, description, taskInputs = [], mcpOverallComplexity, projectRoot = process.cwd()) {
+    if (!isUserAsidesEnabled(projectRoot))
+        return null;
+    const safeId = assertSafeAsideId(asideId);
+    const taskTypes = taskInputs.map((t) => t.type ?? 'implement');
+    const basePlan = buildLeadDevPlan(description, taskTypes, taskInputs, mcpOverallComplexity);
+    if (!basePlan)
+        return null;
+    return {
+        version: USER_ASIDE_STATE_VERSION,
+        id: safeId,
+        title,
+        status: 'active',
+        description,
+        persistedAt: new Date().toISOString(),
+        plan: {
+            ...basePlan,
+            description: `[Aside ${safeId}] ${description}`,
+            phases: remapPhasesToAsidePrefix(safeId, basePlan.phases),
+        },
+    };
+}
+/** Merge new task intake into an existing aside (re-intake). */
+export function mergeUserAsideIntake(existing, description, taskInputs, mcpOverallComplexity, projectRoot = process.cwd()) {
+    const fresh = buildUserAsidePlan(existing.id, existing.title, description || existing.description, taskInputs.length > 0 ? taskInputs : [{ description: existing.description, type: 'implement' }], mcpOverallComplexity, projectRoot);
+    if (!fresh)
+        return existing;
+    const mergedPhases = [...existing.plan.phases];
+    for (const phase of fresh.plan.phases) {
+        const match = mergedPhases.find((p) => p.id === phase.id);
+        if (match) {
+            const existingIds = new Set(match.todos.map((t) => t.id));
+            for (const todo of phase.todos) {
+                if (!existingIds.has(todo.id))
+                    match.todos.push(todo);
+            }
+        }
+        else {
+            mergedPhases.push(phase);
+        }
+    }
+    return {
+        ...existing,
+        description: description || existing.description,
+        status: existing.status === 'completed' ? 'active' : existing.status,
+        plan: { ...existing.plan, phases: mergedPhases },
+    };
+}
+export function loadUserAside(asideId, projectRoot = process.cwd()) {
+    try {
+        const filePath = userAsidePath(asideId, projectRoot);
+        if (!fs.existsSync(filePath))
+            return null;
+        const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        return validateLoadedAside(parsed, assertSafeAsideId(asideId));
+    }
+    catch {
+        return null;
+    }
+}
+export function saveUserAside(aside, projectRoot = process.cwd()) {
+    assertSafeAsideId(aside.id);
+    const dir = userAsidesDir(projectRoot);
+    fs.mkdirSync(dir, { recursive: true });
+    const filePath = userAsidePath(aside.id, projectRoot);
+    const payload = {
+        ...aside,
+        version: USER_ASIDE_STATE_VERSION,
+        persistedAt: new Date().toISOString(),
+    };
+    fs.writeFileSync(filePath, JSON.stringify(payload, null, 2));
+    return filePath;
+}
+export function listUserAsideIds(projectRoot = process.cwd()) {
+    const dir = userAsidesDir(projectRoot);
+    if (!fs.existsSync(dir))
+        return [];
+    return fs
+        .readdirSync(dir)
+        .filter((f) => f.endsWith('.json') && f !== '_active.json')
+        .map((f) => f.replace(/\.json$/, ''))
+        .filter((id) => USER_ASIDE_ID_PATTERN.test(id));
+}
+export function loadActiveAsidePointer(projectRoot = process.cwd()) {
+    const pointerPath = activeAsidePointerPath(projectRoot);
+    if (!fs.existsSync(pointerPath))
+        return null;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(pointerPath, 'utf8'));
+        if (!parsed?.asideId)
+            return null;
+        assertSafeAsideId(parsed.asideId);
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function getActiveAsideId(projectRoot = process.cwd(), sessionId) {
+    if (!isUserAsidesEnabled(projectRoot))
+        return null;
+    const pointer = loadActiveAsidePointer(projectRoot);
+    if (!pointer)
+        return null;
+    if (pointer.sessionId) {
+        if (!sessionId || pointer.sessionId !== sessionId)
+            return null;
+    }
+    const aside = loadUserAside(pointer.asideId, projectRoot);
+    if (!aside || aside.status !== 'active')
+        return null;
+    return pointer.asideId;
+}
+export function setActiveAsideId(asideId, projectRoot = process.cwd(), sessionId) {
+    const safeId = assertSafeAsideId(asideId);
+    const aside = loadUserAside(safeId, projectRoot);
+    if (!aside) {
+        throw new UserAsideValidationError(`Cannot activate aside "${safeId}" — file not found at .xray/state/asides/${safeId}.json`);
+    }
+    if (aside.status !== 'active' && aside.status !== 'paused') {
+        throw new UserAsideValidationError(`Cannot activate aside "${safeId}" — status is ${aside.status}`);
+    }
+    if (aside.status === 'paused') {
+        aside.status = 'active';
+        saveUserAside(aside, projectRoot);
+    }
+    const dir = userAsidesDir(projectRoot);
+    fs.mkdirSync(dir, { recursive: true });
+    const pointer = {
+        asideId: safeId,
+        activatedAt: new Date().toISOString(),
+        ...(sessionId ? { sessionId } : {}),
+    };
+    fs.writeFileSync(activeAsidePointerPath(projectRoot), JSON.stringify(pointer, null, 2));
+    return pointer;
+}
+export function clearActiveAside(projectRoot = process.cwd()) {
+    const pointerPath = activeAsidePointerPath(projectRoot);
+    if (!fs.existsSync(pointerPath))
+        return false;
+    fs.unlinkSync(pointerPath);
+    return true;
+}
+export function loadActiveUserAside(projectRoot = process.cwd(), sessionId) {
+    const id = getActiveAsideId(projectRoot, sessionId);
+    if (!id) {
+        const pointer = loadActiveAsidePointer(projectRoot);
+        if (pointer) {
+            const aside = loadUserAside(pointer.asideId, projectRoot);
+            if (aside && aside.status !== 'active')
+                clearActiveAside(projectRoot);
+        }
+        return null;
+    }
+    const aside = loadUserAside(id, projectRoot);
+    if (!aside || aside.status !== 'active') {
+        clearActiveAside(projectRoot);
+        return null;
+    }
+    return aside;
+}
+/** PersistedLeadDevPlan view of an aside for spawn-gate reuse. */
+export function asideToSpawnPlan(aside) {
+    const plan = { ...aside.plan };
+    if (aside.persistedAt)
+        plan.persistedAt = aside.persistedAt;
+    if (aside.sessionId)
+        plan.sessionId = aside.sessionId;
+    return plan;
+}
+/** Aside routable when active for session, or pointer is unscoped (accepted exception). */
+export function isAsideActiveForSession(asideId, projectRoot = process.cwd(), sessionId) {
+    const activeId = getActiveAsideId(projectRoot, sessionId);
+    if (activeId === asideId)
+        return true;
+    const pointer = loadActiveAsidePointer(projectRoot);
+    if (!pointer || pointer.asideId !== asideId)
+        return false;
+    if (!pointer.sessionId)
+        return true;
+    return Boolean(sessionId && pointer.sessionId === sessionId);
+}
+export function findAsideContainingTodo(todoId, projectRoot = process.cwd(), preferredAsideId) {
+    if (!isUserAsideTodoId(todoId))
+        return null;
+    if (preferredAsideId) {
+        const direct = loadUserAside(preferredAsideId, projectRoot);
+        if (direct) {
+            const hit = allPlanTodos(asideToSpawnPlan(direct)).some((t) => t.id === todoId);
+            if (hit)
+                return direct;
+        }
+    }
+    const parsedId = parseAsideIdFromTodoId(todoId);
+    if (parsedId) {
+        const aside = loadUserAside(parsedId, projectRoot);
+        if (aside) {
+            const hit = allPlanTodos(asideToSpawnPlan(aside)).some((t) => t.id === todoId);
+            if (hit)
+                return aside;
+        }
+    }
+    return null;
+}
+export function updateUserAsideTodoStatus(todoId, status, projectRoot = process.cwd(), sessionId) {
+    const parsedId = parseAsideIdFromTodoId(todoId);
+    let aside = parsedId
+        ? findAsideContainingTodo(todoId, projectRoot, parsedId)
+        : null;
+    if (aside && parsedId && !isAsideActiveForSession(parsedId, projectRoot, sessionId)) {
+        aside = null;
+    }
+    if (!aside)
+        aside = loadActiveUserAside(projectRoot, sessionId);
+    if (!aside)
+        return false;
+    let updated = false;
+    for (const phase of aside.plan.phases) {
+        for (const todo of phase.todos) {
+            if (todo.id === todoId) {
+                todo.status = status;
+                updated = true;
+            }
+        }
+    }
+    if (!updated)
+        return false;
+    const outstanding = getOutstandingTodos(asideToSpawnPlan(aside));
+    if (outstanding.length === 0) {
+        aside.status = 'completed';
+        clearActiveAside(projectRoot);
+    }
+    saveUserAside(aside, projectRoot);
+    return true;
+}
+export function getNextAsideTodo(aside) {
+    return getNextRequiredTodo(asideToSpawnPlan(aside));
+}
+export function formatUserAsideSummary(aside) {
+    const todos = allPlanTodos(asideToSpawnPlan(aside));
+    const done = todos.filter((t) => t.status === 'completed').length;
+    const lines = [
+        `**Aside \`${aside.id}\`** — ${aside.title}`,
+        `Status: ${aside.status} | Todos: ${done}/${todos.length}`,
+        aside.worktree ? `Worktree: \`${aside.worktree}\`` : null,
+        aside.branch ? `Branch: \`${aside.branch}\`` : null,
+        '',
+        ...todos.map((t) => `- [${t.status === 'completed' ? 'x' : ' '}] ${t.id} (${t.subagent}): ${t.task}`),
+    ].filter(Boolean);
+    return lines.join('\n');
+}
+export function getUserAsideBootHints(projectRoot = process.cwd(), sessionId) {
+    if (!isUserAsidesEnabled(projectRoot))
+        return null;
+    const aside = loadActiveUserAside(projectRoot, sessionId);
+    if (!aside)
+        return null;
+    const hints = {
+        activeAside: aside.id,
+        asideTitle: aside.title,
+        asideStatus: aside.status,
+        asideTodoPrefix: `${aside.id}.a.*`,
+        asideHint: 'Spawns route to active aside todos; orchestrate-task clearActiveAside to resume main',
+    };
+    if (aside.worktree)
+        hints.asideWorktree = aside.worktree;
+    if (aside.branch)
+        hints.asideBranch = aside.branch;
+    if (aside.governance?.trapSignals?.length) {
+        hints.asideTrapSignals = aside.governance.trapSignals;
+    }
+    if (aside.governance?.conferOnPhaseStart) {
+        hints.asideConferRecommended = true;
+        hints.asideConferTrigger = 'orchestrate-task { confer: true } or synthesis analyze-complexity';
+    }
+    return hints;
+}

package/dist/postprocessor/PostProcessor.d.ts

@@ -23,6 +23,7 @@ export declare class PostProcessor {
     private escalationEngine;
     private successHandler;
     private triggers;
+    private metamorphosisEngines;
     constructor(stateManager: XrayStateManager, sessionMonitor?: SessionMonitor | null, config?: Partial<PostProcessorConfig>);
     /**
      * Generate automated framework report if conditions are met

package/dist/postprocessor/PostProcessor.js

@@ -25,6 +25,7 @@ import { defaultConfig } from "./config.js";
 import { frameworkReportingSystem } from "../reporting/framework-reporting-system.js";
 import { ReportContentValidator } from "../validation/report-content-validator.js";
 import { RegressionAnalysisService } from "./services/RegressionAnalysisService.js";
+import { SelfProposalEngine } from "./metamorphosis/SelfProposalEngine.js";
 export class PostProcessor {
     stateManager;
     sessionMonitor;
@@ -39,6 +40,7 @@ export class PostProcessor {
     escalationEngine;
     successHandler;
     triggers;
+    metamorphosisEngines;
     constructor(stateManager, sessionMonitor = null, config = {}) {
         this.stateManager = stateManager;
         this.sessionMonitor = sessionMonitor;
@@ -56,6 +58,7 @@ export class PostProcessor {
         // Initialize escalation and success handlers
         this.escalationEngine = new EscalationEngine(this.config.escalation);
         this.successHandler = new SuccessHandler(this.config.success);
+        this.metamorphosisEngines = [new SelfProposalEngine({ projectRoot: process.cwd() })];
         // Initialize trigger mechanisms
         this.triggers = {
             gitHook: new GitHookTrigger(this),
@@ -736,6 +739,14 @@ All path violations will be automatically detected and blocked.
                 };
                 // Handle successful completion
                 await this.successHandler.handleSuccess(context, result, monitoringResults);
+                for (const engine of this.metamorphosisEngines) {
+                    try {
+                        await engine.onPhase('post-process-complete', { context, result, monitoringResults });
+                    }
+                    catch (metaErr) {
+                        await frameworkLogger.log('-post-processor', 'self-proposal-phase-error', 'warning', { error: String(metaErr) });
+                    }
+                }
                 // AGENTS.md auto-update with smart triggers
                 // Only updates when agent-related files have changed
                 const agentChangePatterns = [

package/dist/processors/implementations/session-summary-processor.d.ts

@@ -2,7 +2,7 @@
  * Session Summary Post-Processor
  *
  * Generates emoji-formatted session summaries after tool execution.
- * Uses features.json -> auto_reporting config for control.
+ * Uses features.json -> autonomous_reporting config for control.
  *
  * @since 2026-04-04
  */

package/dist/processors/implementations/session-summary-processor.js

@@ -2,7 +2,7 @@
  * Session Summary Post-Processor
  *
  * Generates emoji-formatted session summaries after tool execution.
- * Uses features.json -> auto_reporting config for control.
+ * Uses features.json -> autonomous_reporting config for control.
  *
  * @since 2026-04-04
  */
@@ -29,12 +29,15 @@ export class SessionSummaryProcessor extends PostProcessor {
     loadConfig() {
         try {
             const configData = featuresConfigLoader.loadConfig();
-            const autoReporting = configData.auto_reporting;
+            const autoReporting = configData.autonomous_reporting ?? configData.auto_reporting;
             if (autoReporting) {
-                this.config.enabled = autoReporting.mode !== "off";
-                this.config.include_emojis = autoReporting.display?.indicators?.emojis !== false;
-                this.config.include_recommendations = autoReporting.report_types?.session_summary?.include_recommendations !== false;
-                this.config.include_agent_activities = autoReporting.report_types?.session_summary?.include_agent_activities !== false;
+                this.config.enabled = autoReporting.enabled !== false;
+                this.config.include_emojis =
+                    autoReporting.include_agent_activities !== false;
+                this.config.include_recommendations =
+                    autoReporting.include_recommendations !== false;
+                this.config.include_agent_activities =
+                    autoReporting.include_agent_activities !== false;
             }
         }
         catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0xray",
-  "version": "3.5.4",
+  "version": "3.5.5",
   "description": "Multi-agent orchestration and Codex governance for OpenCode, Hermes, Grok Build, and OpenClaw",
   "readme": "README.md",
   "license": "MIT",
@@ -64,7 +64,7 @@
     "version:bump": "node scripts/node/version-manager.mjs",
     "version": "node scripts/node/version-manager.mjs",
     "prebuild": "rm -rf dist tsconfig.tsbuildinfo tsconfig.*.tsbuildinfo",
-    "build": "tsc && mkdir -p dist/public dist/scripts && cp -r public/* dist/public/ && cp scripts/hooks/pre-command dist/scripts/ && cp scripts/hooks/pre-command.mjs dist/scripts/ && cp README.md AGENTS.md SKILLS.md CHANGELOG.md LICENSE .gitignore.default dist/ && find src -name '*.mjs' ! -path '*/__tests__/*' | while read f; do tgt=\"dist/${f#src/}\"; mkdir -p \"$(dirname $tgt)\"; cp \"$f\" \"$tgt\"; done && for dir in skills integrations mcps; do find src/$dir -type f ! -name '*.ts' ! -path '*/.pytest_cache/*' | while read f; do tgt=\"dist/${f#src/}\"; mkdir -p \"$(dirname $tgt)\"; cp \"$f\" \"$tgt\"; done; done && mkdir -p dist/plugin && (find dist/plugin -name '*codex-injection*.js' -exec cp {} dist/plugin/xray-codex-injection.js \\; 2>/dev/null || true) && cp -r src/opencode/ .opencode/ && mkdir -p .xray && for f in codex.json features.json features.schema.json config.json; do cp xray/$f .xray/$f 2>/dev/null || true; done",
+    "build": "tsc && chmod +x dist/cli/index.js && mkdir -p dist/public dist/scripts && cp -r public/* dist/public/ && cp scripts/hooks/pre-command dist/scripts/ && cp scripts/hooks/pre-command.mjs dist/scripts/ && cp README.md AGENTS.md SKILLS.md CHANGELOG.md LICENSE .gitignore.default dist/ && find src -name '*.mjs' ! -path '*/__tests__/*' | while read f; do tgt=\"dist/${f#src/}\"; mkdir -p \"$(dirname $tgt)\"; cp \"$f\" \"$tgt\"; done && for dir in skills integrations mcps; do find src/$dir -type f ! -name '*.ts' ! -path '*/.pytest_cache/*' | while read f; do tgt=\"dist/${f#src/}\"; mkdir -p \"$(dirname $tgt)\"; cp \"$f\" \"$tgt\"; done; done && mkdir -p dist/plugin && (find dist/plugin -name '*codex-injection*.js' -exec cp {} dist/plugin/xray-codex-injection.js \\; 2>/dev/null || true) && cp -r src/opencode/ .opencode/ && mkdir -p .xray && for f in codex.json features.json features.schema.json config.json; do cp xray/$f .xray/$f 2>/dev/null || true; done",
     "build:all": "npm run build",
     "ci-install": "npm ci",
     "clean": "rm -rf dist tsconfig.tsbuildinfo tsconfig.*.tsbuildinfo",
@@ -129,11 +129,16 @@
     "verify:orchestrator-behavior": "npm run build && node scripts/mjs/verify-orchestrator-behavior.mjs",
     "verify:grok-delegation-gate": "npm run build && node scripts/mjs/verify-grok-delegation-gate.mjs && node scripts/mjs/verify-grok-synthesis-gate.mjs",
     "verify:grok-synthesis-gate": "npm run build && node scripts/mjs/verify-grok-synthesis-gate.mjs",
-    "verify:hermes-delegation-gate": "npm run build && node scripts/mjs/verify-hermes-delegation-gate.mjs",
+    "verify:hermes-delegation-gate": "npm run build && node scripts/mjs/verify-hermes-delegation-gate.mjs && node scripts/mjs/verify-hermes-session-start.mjs",
     "verify:delegation-gate": "npm run build && node scripts/mjs/verify-delegation-gate-core.mjs --host=grok && node scripts/mjs/verify-delegation-gate-core.mjs --host=hermes && node scripts/mjs/verify-delegation-gate-core.mjs --host=opencode && node scripts/mjs/verify-grok-delegation-gate.mjs && node scripts/mjs/verify-grok-synthesis-gate.mjs && node scripts/mjs/verify-hermes-delegation-gate.mjs",
-    "verify:synthesis": "npm run build && node scripts/mjs/verify-synthesis-core.mjs && node scripts/mjs/verify-synthesis-gate-core.mjs && node scripts/mjs/verify-synthesis-outcome-core.mjs && node scripts/mjs/verify-synthesis-p2-core.mjs && node scripts/mjs/verify-synthesis-e2e-core.mjs",
+    "verify:synthesis": "npm run build && node scripts/mjs/verify-synthesis-core.mjs && node scripts/mjs/verify-synthesis-gate-core.mjs && node scripts/mjs/verify-synthesis-outcome-core.mjs && node scripts/mjs/verify-synthesis-p2-core.mjs && node scripts/mjs/verify-synthesis-e2e-core.mjs && node scripts/mjs/verify-confer-core.mjs",
+    "verify:confer": "npm run build && node scripts/mjs/verify-confer-core.mjs",
+    "verify:user-aside": "npm run build && node scripts/mjs/verify-user-aside-core.mjs",
+    "verify:pipeline-facets": "npm run build && node scripts/mjs/verify-pipeline-facets.mjs",
     "verify:find-project-root": "node scripts/mjs/verify-find-project-root-core.mjs",
-    "verify:consumer-gitignore": "node scripts/mjs/verify-consumer-gitignore-core.mjs"
+    "verify:consumer-gitignore": "node scripts/mjs/verify-consumer-gitignore-core.mjs",
+    "verify:pre-commit-diff": "node scripts/mjs/verify-pre-commit-diff-core.mjs",
+    "verify:pre-push-diff": "node scripts/mjs/verify-pre-push-diff-core.mjs"
   },
   "files": [
     "dist/",
@@ -149,6 +154,10 @@
     "scripts/mjs/verify-grok-delegation-gate.mjs",
     "scripts/mjs/verify-grok-synthesis-gate.mjs",
     "scripts/mjs/verify-hermes-delegation-gate.mjs",
+    "scripts/mjs/verify-hermes-session-start.mjs",
+    "scripts/mjs/verify-pre-push-diff-core.mjs",
+    "scripts/mjs/verify-confer-core.mjs",
+    "scripts/mjs/verify-user-aside-core.mjs",
     "scripts/mjs/verify-delegation-gate-core.mjs",
     "scripts/mjs/delegation-gate-fixture.mjs",
     "src/opencode/",

package/scripts/hooks/install-hooks.cjs

@@ -108,9 +108,9 @@ BRANCH=$(git rev-parse --abbrev-ref HEAD)
 ) &
 
 MODE="minimal"
-COMMIT_THRESHOLD=25
+COMMIT_THRESHOLD=50
 DAYS_THRESHOLD=14
-AUTO_GENERATE=true
+AUTO_GENERATE=false
 PROMPT_USER=true
 
 if command -v node >/dev/null 2>&1; then
@@ -119,7 +119,7 @@ if command -v node >/dev/null 2>&1; then
     export PROJECT_ROOT="$PROJECT_ROOT"
     REFLECTION_JSON=$(node "$LOAD_SCRIPT" --json 2>/dev/null || echo '{}')
     MODE=$(node -e 'const c=JSON.parse(process.argv[1]);process.stdout.write(String(c.mode||"minimal"))' "$REFLECTION_JSON")
-    COMMIT_THRESHOLD=$(node -e 'const c=JSON.parse(process.argv[1]);process.stdout.write(String(c.commitThreshold??25))' "$REFLECTION_JSON")
+    COMMIT_THRESHOLD=$(node -e 'const c=JSON.parse(process.argv[1]);process.stdout.write(String(c.commitThreshold??50))' "$REFLECTION_JSON")
     DAYS_THRESHOLD=$(node -e 'const c=JSON.parse(process.argv[1]);process.stdout.write(String(c.daysThreshold??14))' "$REFLECTION_JSON")
     AUTO_GENERATE=$(node -e 'const c=JSON.parse(process.argv[1]);process.stdout.write(c.autoGenerate===false?"false":"true")' "$REFLECTION_JSON")
     PROMPT_USER=$(node -e 'const c=JSON.parse(process.argv[1]);process.stdout.write(c.promptUser===false?"false":"true")' "$REFLECTION_JSON")