0xray 3.5.4 → 3.5.5

package/dist/integrations/grok/hooks/session-start.js

@@ -15,6 +15,12 @@ import {
 } from './grok-hook-utils.js';
 import { appendHookActivity } from './grok-hook-activity.js';
 import { recordSynthesisTurnSlice } from '../../hooks/synthesis-hook-runtime.mjs';
+import { archiveStaleLeadDevPlan } from '../../hooks/plan-hook-runtime.mjs';
+import {
+  maybeRunReflectionStub,
+  scheduleAutonomousReportingMarker,
+  runInferenceImprovementLight,
+} from '../../hooks/pipeline-hook-runtime.mjs';
 
 function resolveHookEvent(event) {
   if (process.env.GROK_HOOK_EVENT) return process.env.GROK_HOOK_EVENT;
@@ -47,6 +53,18 @@ async function main() {
         sessionId,
       });
     }
+
+    try {
+      const archived = archiveStaleLeadDevPlan(eventRoot);
+      if (archived.archived) {
+        appendHookActivity(eventRoot, 'grok-session-start', 'stale-plan-archived', 'info', {
+          archivePath: archived.archivePath,
+          reason: archived.reason,
+        });
+      }
+    } catch {
+      /* non-blocking */
+    }
     const source =
       HOOK_EVENT === 'user_prompt_submit'
         ? '0xray/grok-user-prompt-submit'
@@ -65,6 +83,16 @@ async function main() {
       lead_dev_mode: payload.lead_dev_mode,
     });
 
+    try {
+      scheduleAutonomousReportingMarker(eventRoot);
+      if (HOOK_EVENT === 'session_start') {
+        maybeRunReflectionStub(eventRoot);
+        runInferenceImprovementLight(eventRoot);
+      }
+    } catch {
+      /* non-blocking pipeline facets */
+    }
+
     console.log(JSON.stringify(payload));
     process.exit(0);
   } catch (err) {

package/dist/integrations/hermes-agent/__init__.py

@@ -206,6 +206,10 @@ def _delegation_gate_block(tool_name: str, args: dict, task_id: str, **kwargs):
         },
         timeout=10,
     )
+    if bridge_result.get("error") and bridge_result.get("allow") is not False:
+        err = bridge_result.get("error", "delegation-gate bridge error")
+        _log_to_file("activity.log", f"[delegation-gate] bridge-error tool={tool_name} {err}")
+        return {"action": "block", "message": err}
     if bridge_result.get("allow") is False:
         reason = bridge_result.get("reason", "Delegation gate blocked this tool")
         gate = bridge_result.get("gate", "delegation-gate")
@@ -376,6 +380,8 @@ def _on_post_tool_call(tool_name: str, args: dict, result, task_id: str, **kwarg
                 "args": args or {},
                 "sessionId": session_id,
                 "host": "hermes",
+                "toolOutput": result,
+                "result": result,
             },
             timeout=10,
         )
@@ -452,6 +458,10 @@ def _on_session_start(session_id: str, platform: str, **kwargs):
     _ensure_log_dir()
     _log_to_file("activity.log",
         f"[session-start] session={session_id} platform={platform}")
+    try:
+        _call_bridge({"command": "session-start", "sessionId": session_id}, timeout=10)
+    except Exception as e:
+        logger.debug("[xray] session-start bridge skipped: %s", e)
     logger.info("[xray] Session %s started on %s", session_id, platform)
 
 
@@ -771,7 +781,7 @@ def register(ctx):
 
     # Log session-start since on_session_start may not fire in oneshot mode
     _log_to_file("activity.log",
-        f"[session-start] session={session_id}")
+        "[session-start] session=bootstrap source=plugin-load")
 
     logger.info(
         "[xray] Plugin v2.2 loaded: 6 tools, 2 hooks, "

package/dist/integrations/hermes-agent/bridge.mjs

@@ -15,6 +15,7 @@
  *   codex-check   - Check code against codex rules
  *   stats         - Return bridge/framework statistics
  *   hooks         - Manage git hooks (install, uninstall, list, status)
+ *   session-start - Session boot: archive stale lead-dev plans (synthesis exempt)
  *   govern        - Govern inference proposals through weighted voting
  *   apply         - Govern + apply approved inference proposals
  *
@@ -36,13 +37,42 @@ import {
   unlinkSync,
   renameSync,
 } from "fs";
-import { join, dirname, relative } from "path";
-import { fileURLToPath } from "url";
+import { join, dirname, relative, resolve } from "path";
+import { fileURLToPath, pathToFileURL } from "url";
 import { homedir } from "os";
-import { findProjectRoot } from "../../../scripts/helpers/find-project-root.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
+/** Resolve find-project-root from plugin install, dist layout, or consumer node_modules. */
+function resolveFindProjectRootPath() {
+  const candidates = [];
+  const marker = join(__dirname, "xray-consumer-root.txt");
+  if (existsSync(marker)) {
+    try {
+      const marked = readFileSync(marker, "utf-8").trim();
+      if (marked) {
+        candidates.push(
+          join(marked, "node_modules", "0xray", "scripts", "helpers", "find-project-root.mjs"),
+        );
+      }
+    } catch {
+      /* fall through */
+    }
+  }
+  candidates.push(
+    join(__dirname, "scripts", "helpers", "find-project-root.mjs"),
+    join(__dirname, "..", "..", "..", "scripts", "helpers", "find-project-root.mjs"),
+    join(__dirname, "../../../scripts/helpers/find-project-root.mjs"),
+  );
+  for (const candidate of candidates) {
+    const abs = resolve(candidate);
+    if (existsSync(abs)) return abs;
+  }
+  throw new Error("find-project-root.mjs not found — re-run: npx 0xray hermes install --force");
+}
+
+const { findProjectRoot } = await import(pathToFileURL(resolveFindProjectRootPath()).href);
+
 // ── Framework components (lazy-loaded) ───────────────────────
 let ProcessorManager = null;
 let XrayStateManager = null;
@@ -389,6 +419,27 @@ async function handleHealth(input) {
   };
 }
 
+async function handleSessionStart(input, projectRoot, logDir) {
+  const sessionId = input.sessionId || `bridge-${Date.now()}`;
+  let planArchive = { archived: false };
+
+  try {
+    const { archiveStaleLeadDevPlan } = await import('../hooks/plan-hook-runtime.mjs');
+    planArchive = archiveStaleLeadDevPlan(projectRoot);
+    if (planArchive.archived) {
+      logToActivity(
+        logDir,
+        `session-start: stale-plan-archived path=${planArchive.archivePath ?? 'unknown'}`,
+      );
+    }
+  } catch {
+    /* non-blocking — dist may be absent during dev */
+  }
+
+  logToActivity(logDir, `session-start: session=${sessionId} source=bridge`);
+  return { ok: true, sessionId, planArchive };
+}
+
 async function handlePreProcess(input, projectRoot, logDir) {
   const { tool, args } = input;
   const startTime = Date.now();
@@ -766,7 +817,7 @@ async function handleApply(input, projectRoot, logDir) {
 // ── Known commands for positional-arg mode ──────────────────
 const KNOWN_COMMANDS = new Set([
   "health", "stats", "pre-process", "post-process", "validate", "codex-check", "hooks", "govern", "apply",
-  "skill-install", "skill-registry", "delegation-gate",
+  "skill-install", "skill-registry", "delegation-gate", "session-start",
 ]);
 
 async function recordHermesSynthesisTurn(projectRoot, sessionId) {
@@ -792,7 +843,12 @@ async function handleDelegationGate(command, projectRoot, logDir) {
       if (!gate.isSubagentTool(tool)) {
         return { allow: true, phase: "post", skipped: true };
       }
-      const result = gate.evaluatePostToolSpawn(tool, args, projectRoot);
+      const toolOutput =
+        command.toolOutput ?? command.result ?? command.output ?? args?.result ?? null;
+      const result = gate.evaluatePostToolSpawn(tool, args, projectRoot, {
+        sessionId,
+        toolOutput,
+      });
       if (result.satisfied.length > 0) {
         logToActivity(
           logDir,
@@ -823,7 +879,15 @@ async function handleDelegationGate(command, projectRoot, logDir) {
 
     return { phase: "pre", ...outcome };
   } catch (error) {
-    return { error: `delegation-gate failed: ${error.message || error}` };
+    const message = `delegation-gate failed: ${error.message || error}`;
+    logToActivity(logDir, `[delegation-gate] error ${message}`);
+    return {
+      allow: false,
+      phase: "pre",
+      gate: "delegation-gate-error",
+      reason: message,
+      error: message,
+    };
   }
 }
 
@@ -910,10 +974,6 @@ async function main() {
   const projectRoot = resolveBridgeProjectRoot();
   const logDir = ensureLogDir(projectRoot);
 
-  // Log session start for test verification
-  const sessionId = `bridge-${Date.now()}`;
-  logToActivity(logDir, `session-start: session=${sessionId} source=bridge`);
-
   // Lazy-load framework on first call
   if (!frameworkReady && !frameworkLoadAttempted) {
     await loadFramework(projectRoot);
@@ -956,6 +1016,9 @@ async function main() {
     case "skill-registry":
       response = await handleSkillRegistry(command, projectRoot, logDir);
       break;
+    case "session-start":
+      response = await handleSessionStart(command, projectRoot, logDir);
+      break;
     case "delegation-gate":
       response = await handleDelegationGate(command, projectRoot, logDir);
       break;

package/dist/integrations/hooks/confer-hook-runtime.mjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+/**
+ * Lazy-load confer SSOT for Grok session-boot hints.
+ */
+import { createRequire } from 'node:module';
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function resolvePackageRoot() {
+  let dir = __dirname;
+  for (let i = 0; i < 10; i++) {
+    const pkg = join(dir, 'package.json');
+    if (existsSync(pkg)) {
+      try {
+        const require = createRequire(join(dir, 'package.json'));
+        if (require('./package.json').name === '0xray') return dir;
+      } catch {
+        /* continue */
+      }
+    }
+    const nm = join(dir, 'node_modules', '0xray', 'package.json');
+    if (existsSync(nm)) return dirname(nm);
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return resolve(__dirname, '../../..');
+}
+
+function loadConfer() {
+  const root = resolvePackageRoot();
+  const candidates = [
+    join(__dirname, '../../nucleus/confer.js'),
+    join(root, 'dist/nucleus/confer.js'),
+    join(process.cwd(), 'node_modules/0xray/dist/nucleus/confer.js'),
+  ];
+  const found = candidates.find((p) => existsSync(p));
+  if (!found) return null;
+  return createRequire(import.meta.url)(found);
+}
+
+export function isConferPendingForSession(projectRoot, sessionId = null) {
+  const mod = loadConfer();
+  if (!mod?.isConferPending) return false;
+  return mod.isConferPending(projectRoot, sessionId);
+}

package/dist/integrations/hooks/pipeline-hook-runtime.mjs

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+/**
+ * Pipeline facet hooks — reflection, routing outcomes, reporting, inference-improvement.
+ * Loaded by Grok session-start / post-tool-use (rewire only, no new MCP surface).
+ */
+import { createRequire } from 'node:module';
+import { execSync, spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function resolvePackageRoot() {
+  let dir = __dirname;
+  for (let i = 0; i < 10; i++) {
+    const pkg = join(dir, 'package.json');
+    if (existsSync(pkg)) {
+      try {
+        const require = createRequire(join(dir, 'package.json'));
+        if (require('./package.json').name === '0xray') return dir;
+      } catch {
+        /* continue */
+      }
+    }
+    const nm = join(dir, 'node_modules', '0xray', 'package.json');
+    if (existsSync(nm)) return dirname(nm);
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return resolve(__dirname, '../../..');
+}
+
+function loadFeatures(projectRoot) {
+  const path = join(projectRoot, '.xray', 'features.json');
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function appendActivity(projectRoot, action, level, data = {}) {
+  const logDir = join(projectRoot, 'logs', 'framework');
+  mkdirSync(logDir, { recursive: true });
+  const line = JSON.stringify({
+    timestamp: new Date().toISOString(),
+    component: 'pipeline-hook',
+    action,
+    level,
+    data,
+  });
+  appendFileSync(join(logDir, 'activity.log'), `${line}\n`);
+}
+
+function gitCommitCount(projectRoot) {
+  try {
+    const out = execSync('git rev-list --count HEAD', { cwd: projectRoot, encoding: 'utf8' }).trim();
+    const n = parseInt(out, 10);
+    return Number.isFinite(n) ? n : 0;
+  } catch {
+    return 0;
+  }
+}
+
+/** P1.1 — reflection stub when synthesis.reflection triggers fire */
+export function maybeRunReflectionStub(projectRoot) {
+  const features = loadFeatures(projectRoot);
+  const reflection = features.synthesis?.reflection;
+  if (!reflection || reflection.mode === 'off') return null;
+
+  const threshold = reflection.thresholds?.[reflection.mode ?? 'minimal'];
+  const commitTrigger = reflection.triggers?.commit_threshold;
+  const commits = gitCommitCount(projectRoot);
+  const commitLimit = commitTrigger?.threshold ?? threshold?.commit_threshold ?? 25;
+
+  if (!commitTrigger?.enabled && !threshold?.auto_generate) return null;
+  if (commits > 0 && commits % commitLimit !== 0) return null;
+
+  const pkgRoot = resolvePackageRoot();
+  const generator = join(pkgRoot, 'scripts', 'node', 'auto-reflection-generator.mjs');
+  if (!existsSync(generator)) return null;
+
+  const result = spawnSync(
+    process.execPath,
+    [generator, '--trigger', 'commit-threshold', '--title', `Pipeline checkpoint (${commits} commits)`],
+    { cwd: projectRoot, encoding: 'utf8', timeout: 15000 },
+  );
+
+  appendActivity(projectRoot, 'reflection-stub', result.status === 0 ? 'success' : 'warning', {
+    commits,
+    exitCode: result.status,
+    stdout: (result.stdout || '').slice(0, 200),
+  });
+
+  return { triggered: true, commits, exitCode: result.status };
+}
+
+/** P1.2 — record routing outcome after orchestrate / Task spawn */
+export function recordRoutingOutcome(projectRoot, entry) {
+  const logDir = join(projectRoot, 'logs', 'framework');
+  mkdirSync(logDir, { recursive: true });
+  const path = join(logDir, 'routing-outcomes.json');
+  let outcomes = [];
+  if (existsSync(path)) {
+    try {
+      outcomes = JSON.parse(readFileSync(path, 'utf8'));
+      if (!Array.isArray(outcomes)) outcomes = [];
+    } catch {
+      outcomes = [];
+    }
+  }
+  outcomes.push({
+    timestamp: new Date().toISOString(),
+    tool: entry.tool ?? 'unknown',
+    agent: entry.agent ?? entry.subagent ?? null,
+    planTodoId: entry.planTodoId ?? null,
+    success: entry.success ?? true,
+    sessionId: entry.sessionId ?? null,
+  });
+  if (outcomes.length > 500) outcomes = outcomes.slice(-500);
+  writeFileSync(path, `${JSON.stringify(outcomes, null, 2)}\n`);
+  appendActivity(projectRoot, 'routing-outcome', 'info', {
+    tool: entry.tool,
+    agent: entry.agent ?? entry.subagent,
+    count: outcomes.length,
+  });
+  return outcomes.length;
+}
+
+/** P1.3 — mark autonomous reporting scheduled (framework reporter wired at boot in TS path) */
+export function scheduleAutonomousReportingMarker(projectRoot) {
+  const features = loadFeatures(projectRoot);
+  const reporting = features.autonomous_reporting;
+  if (!reporting?.enabled || !reporting?.auto_schedule) return null;
+
+  const reportsDir = join(projectRoot, 'reports');
+  mkdirSync(reportsDir, { recursive: true });
+  const marker = join(reportsDir, '.autonomous-reporting-scheduled.json');
+  writeFileSync(
+    marker,
+    `${JSON.stringify({
+      scheduledAt: new Date().toISOString(),
+      intervalMinutes: reporting.interval_minutes ?? 60,
+    }, null, 2)}\n`,
+  );
+  appendActivity(projectRoot, 'autonomous-report-scheduled', 'info', {
+    intervalMinutes: reporting.interval_minutes ?? 60,
+  });
+  return marker;
+}
+
+/** P1.7 — lightweight inference-improvement workflow stub */
+export function runInferenceImprovementLight(projectRoot) {
+  const features = loadFeatures(projectRoot);
+  if (features.inference_governance?.enabled === false) return null;
+
+  const infDir = join(projectRoot, '.xray', 'inference');
+  mkdirSync(infDir, { recursive: true });
+  const workflowPath = join(infDir, `workflow-${Date.now()}.json`);
+  const payload = {
+    timestamp: new Date().toISOString(),
+    phase: 'pending',
+    triggered: true,
+    mode: 'light',
+    dataLocations: {
+      reflections: 'docs/reflections',
+      logs: 'logs/framework',
+      reports: 'reports',
+    },
+  };
+  writeFileSync(workflowPath, `${JSON.stringify(payload, null, 2)}\n`);
+  appendActivity(projectRoot, 'inference-improvement-light', 'info', { workflowPath });
+  return workflowPath;
+}
+
+/** P2.2 — opt-in lightweight postprocessor on write tools (features.grok_postprocessor_light) */
+export function runGrokPostprocessorLight(projectRoot, entry = {}) {
+  const features = loadFeatures(projectRoot);
+  if (features.grok_postprocessor_light !== true) return null;
+
+  const infDir = join(projectRoot, '.xray', 'inference');
+  mkdirSync(infDir, { recursive: true });
+  const markerPath = join(infDir, 'postprocessor-light-latest.json');
+  const payload = {
+    timestamp: new Date().toISOString(),
+    phase: 'post-process-light',
+    tool: entry.tool ?? 'unknown',
+    paths: entry.paths ?? [],
+    mode: 'grok-pre-tool-light',
+  };
+  writeFileSync(markerPath, `${JSON.stringify(payload, null, 2)}\n`);
+  appendActivity(projectRoot, 'postprocessor-light', 'info', {
+    tool: entry.tool,
+    pathCount: (entry.paths ?? []).length,
+  });
+  return markerPath;
+}
+
+/** P3.3 — pipeline facet snapshot for suit audit */
+export function writePipelineFacetSnapshot(projectRoot, counts) {
+  const outPath = join(projectRoot, 'docs', 'PIPELINE-FACET-SNAPSHOT.json');
+  mkdirSync(dirname(outPath), { recursive: true });
+  writeFileSync(
+    outPath,
+    `${JSON.stringify({ generatedAt: new Date().toISOString(), ...counts }, null, 2)}\n`,
+  );
+  return outPath;
+}

package/dist/integrations/hooks/plan-hook-runtime.mjs

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+/**
+ * Load lead-dev plan persistence from consumer or package dist.
+ * Used by Grok/Hermes session-start for stale plan archival.
+ */
+import { createRequire } from 'node:module';
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function resolvePackageRoot() {
+  let dir = __dirname;
+  for (let i = 0; i < 10; i++) {
+    const pkg = join(dir, 'package.json');
+    if (existsSync(pkg)) {
+      try {
+        const require = createRequire(join(dir, 'package.json'));
+        const name = require('./package.json').name;
+        if (name === '0xray') return dir;
+      } catch {
+        /* continue */
+      }
+    }
+    const nm = join(dir, 'node_modules', '0xray', 'package.json');
+    if (existsSync(nm)) {
+      return dirname(nm);
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return resolve(__dirname, '../../..');
+}
+
+function loadPlanPersistence() {
+  const root = resolvePackageRoot();
+  const candidates = [
+    join(__dirname, '../../nucleus/lead-dev-plan-persistence.js'),
+    join(root, 'dist/nucleus/lead-dev-plan-persistence.js'),
+    join(process.cwd(), 'node_modules/0xray/dist/nucleus/lead-dev-plan-persistence.js'),
+  ];
+  const found = candidates.find((p) => existsSync(p));
+  if (!found) {
+    throw new Error(
+      'lead-dev-plan-persistence.js missing — run npm run build in 0xray',
+    );
+  }
+  return createRequire(import.meta.url)(found);
+}
+
+let persistence;
+
+function getPersistence() {
+  if (!persistence) {
+    persistence = loadPlanPersistence();
+  }
+  return persistence;
+}
+
+export function archiveStaleLeadDevPlan(projectRoot) {
+  return getPersistence().archiveStaleLeadDevPlan(projectRoot);
+}
+
+export function isLeadDevPlanStale(plan, projectRoot) {
+  return getPersistence().isLeadDevPlanStale(plan, projectRoot);
+}

package/dist/integrations/hooks/user-aside-hook-runtime.mjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+/**
+ * Lazy-load user-aside SSOT for Grok session-boot hints.
+ */
+import { createRequire } from 'node:module';
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function resolvePackageRoot() {
+  let dir = __dirname;
+  for (let i = 0; i < 10; i++) {
+    const pkg = join(dir, 'package.json');
+    if (existsSync(pkg)) {
+      try {
+        const require = createRequire(join(dir, 'package.json'));
+        if (require('./package.json').name === '0xray') return dir;
+      } catch {
+        /* continue */
+      }
+    }
+    const nm = join(dir, 'node_modules', '0xray', 'package.json');
+    if (existsSync(nm)) return dirname(nm);
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return resolve(__dirname, '../../..');
+}
+
+function loadUserAside() {
+  const root = resolvePackageRoot();
+  const candidates = [
+    join(__dirname, '../../nucleus/user-aside.js'),
+    join(root, 'dist/nucleus/user-aside.js'),
+    join(process.cwd(), 'node_modules/0xray/dist/nucleus/user-aside.js'),
+  ];
+  const found = candidates.find((p) => existsSync(p));
+  if (!found) return null;
+  return createRequire(import.meta.url)(found);
+}
+
+export function getActiveUserAsideBoot(projectRoot, sessionId = null) {
+  const mod = loadUserAside();
+  if (!mod?.getUserAsideBootHints) return null;
+  return mod.getUserAsideBootHints(projectRoot, sessionId);
+}

package/dist/mcps/architect-tools.server.js

@@ -193,13 +193,18 @@ class XrayArchitectToolsServer extends XrayKnowledgeSkillBase {
     async architectureAssessment(args) {
         const projectRoot = args?.projectRoot || "";
         const assessmentType = args?.assessmentType || "comprehensive";
+        const conferPrompt = typeof args?.conferPrompt === "string" ? args.conferPrompt : "";
         frameworkLogger.log("mcps/architect-tools", "architecture-assessment", "info", { projectRoot });
         const result = await architectArchitectureAssessment(projectRoot, assessmentType);
+        const assessmentJson = JSON.stringify(result, null, 2);
+        const text = conferPrompt.trim()
+            ? `${conferPrompt.trim()}\n\n## Architecture assessment\n${assessmentJson}\n\nVerdict: CONDITIONAL\nTop risks: review assessment metrics above\nHardening: address high-complexity or coupling findings before resuming`
+            : assessmentJson;
         return {
             content: [
                 {
                     type: "text",
-                    text: JSON.stringify(result, null, 2),
+                    text,
                 },
             ],
         };

package/dist/mcps/orchestrator/handlers/complexity-handler.d.ts

@@ -29,6 +29,13 @@ export declare class ComplexityHandler {
         sessionId?: string;
         synthesisCheckpoint?: boolean;
         synthesisDueReason?: string | null;
+        collocatedText?: string | null;
+        conferFixture?: boolean;
+        userAsideId?: string;
+        userAsideTitle?: string;
+        worktree?: string;
+        branch?: string;
+        setActiveAside?: boolean;
     }, asideId?: string): Promise<{
         content: Array<{
             type: string;