0xray 4.0.11 → 4.0.13

package/dist/nucleus/pending-delegations.js

@@ -1,285 +0,0 @@
-/**
- * Pending delegations SSOT — written by task-handler on delegate-deferred.
- * Grok hooks read the same file; PostToolUse never re-parses MCP output.
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { featuresConfigLoader } from '../core/features-config.js';
-import { updatePlanTodoStatus } from './lead-dev-plan-persistence.js';
-export const DEFAULT_PENDING_TTL_MS = 4 * 60 * 60 * 1000;
-const AGENT_ALIASES = {
-    'bug-triage-specialist': 'bug-triage',
-    'code-reviewer': 'code-review',
-    'security-auditor': 'security-audit',
-};
-const TASK_TYPE_BY_AGENT = {
-    'backend-engineer': 'backend-engineer',
-    'frontend-engineer': 'frontend-engineer',
-    'bug-triage': 'bug-triage',
-    'bug-triage-specialist': 'bug-triage',
-    strategist: 'strategist',
-    researcher: 'generalPurpose',
-    'architect-tools': 'generalPurpose',
-    'code-review': 'code-review',
-    'code-reviewer': 'code-review',
-};
-export function pendingDelegationsPath(projectRoot = process.cwd()) {
-    return path.join(projectRoot, '.xray', 'state', 'pending-delegations.json');
-}
-export function leadDevPlanPath(projectRoot = process.cwd()) {
-    return path.join(projectRoot, '.xray', 'state', 'lead-dev-plan.json');
-}
-export function isAutoChainDelegationsEnabled(projectRoot = process.cwd()) {
-    try {
-        const localPath = path.join(projectRoot, '.xray', 'features.json');
-        if (fs.existsSync(localPath)) {
-            const data = JSON.parse(fs.readFileSync(localPath, 'utf8'));
-            const cfg = data.multi_agent_orchestration ?? {};
-            if (cfg.enabled === false || cfg.lead_dev_mode === false)
-                return false;
-            return cfg.auto_chain_delegations !== false;
-        }
-        const cfg = featuresConfigLoader.loadConfig().multi_agent_orchestration;
-        if (!cfg.enabled || cfg.lead_dev_mode === false)
-            return false;
-        return cfg.auto_chain_delegations !== false;
-    }
-    catch {
-        return false;
-    }
-}
-function normalizeAgent(agent) {
-    const key = agent.toLowerCase().trim();
-    return AGENT_ALIASES[key] ?? key;
-}
-function loadLeadDevPlan(projectRoot) {
-    const planPath = leadDevPlanPath(projectRoot);
-    if (!fs.existsSync(planPath))
-        return null;
-    try {
-        return JSON.parse(fs.readFileSync(planPath, 'utf8'));
-    }
-    catch {
-        return null;
-    }
-}
-function allPlanTodos(plan) {
-    return plan.phases.flatMap((p) => p.todos);
-}
-export function matchPlanTodo(agent, taskDescription, taskId, plan) {
-    if (!plan) {
-        return { todo: null, method: 'none', confidence: 0 };
-    }
-    const normalizedAgent = normalizeAgent(agent);
-    const pendingTodos = allPlanTodos(plan).filter((t) => t.status === 'pending');
-    const byTaskId = pendingTodos.find((t) => t.id === taskId || t.task.includes(taskId));
-    if (byTaskId) {
-        return { todo: byTaskId, method: 'taskId', confidence: 0.95 };
-    }
-    const desc = taskDescription.toLowerCase().trim();
-    if (desc) {
-        const byDesc = pendingTodos.find((t) => {
-            const todoText = t.task.toLowerCase();
-            return todoText.includes(desc) || desc.includes(todoText.slice(0, 40));
-        });
-        if (byDesc) {
-            return { todo: byDesc, method: 'description', confidence: 0.75 };
-        }
-    }
-    const byAgent = pendingTodos.find((t) => normalizeAgent(t.subagent) === normalizedAgent);
-    if (byAgent) {
-        return { todo: byAgent, method: 'agent-only', confidence: 0.5 };
-    }
-    return { todo: null, method: 'none', confidence: 0 };
-}
-export function mapSubagentToTaskType(agent) {
-    const key = agent.toLowerCase().trim();
-    return TASK_TYPE_BY_AGENT[key] ?? TASK_TYPE_BY_AGENT[normalizeAgent(key)] ?? 'generalPurpose';
-}
-export function buildSpawnHint(delegation) {
-    const todoLine = delegation.planTodoTask
-        ? `[plan todo ${delegation.planTodoId}] ${delegation.planTodoTask}`
-        : delegation.taskDescription;
-    return {
-        tool: 'Task',
-        subagent_type: mapSubagentToTaskType(delegation.agent),
-        description: `Lead-dev implementation delegation. ${todoLine}. ` +
-            `Complete this todo per .xray/state/lead-dev-plan.json; run per-suite tests; report results.`,
-        planTodoId: delegation.planTodoId,
-        delegationId: delegation.id,
-    };
-}
-export function loadPendingDelegationsState(projectRoot = process.cwd()) {
-    const filePath = pendingDelegationsPath(projectRoot);
-    if (!fs.existsSync(filePath))
-        return null;
-    try {
-        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-    }
-    catch {
-        return null;
-    }
-}
-export function savePendingDelegationsState(state, projectRoot = process.cwd()) {
-    const filePath = pendingDelegationsPath(projectRoot);
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, JSON.stringify(state, null, 2));
-    return filePath;
-}
-function newDelegationId() {
-    return `del-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-}
-export function recordDeferredDelegations(sessionId, deferrals, projectRoot = process.cwd()) {
-    if (!isAutoChainDelegationsEnabled(projectRoot) || deferrals.length === 0) {
-        return [];
-    }
-    const plan = loadLeadDevPlan(projectRoot);
-    const existing = loadPendingDelegationsState(projectRoot);
-    const now = new Date().toISOString();
-    const base = existing && existing.sessionId === sessionId
-        ? existing
-        : {
-            sessionId,
-            createdAt: now,
-            ttlMs: DEFAULT_PENDING_TTL_MS,
-            delegations: [],
-        };
-    const created = [];
-    for (const d of deferrals) {
-        const { todo, method, confidence } = matchPlanTodo(d.agent, d.description, d.taskId, plan);
-        const partial = {
-            id: newDelegationId(),
-            taskId: d.taskId,
-            agent: d.agent,
-            taskDescription: d.description,
-            taskType: d.type ?? 'implement',
-            sessionId,
-            planTodoId: todo?.id ?? null,
-            planTodoTask: todo?.task ?? null,
-            matchMethod: method,
-            matchConfidence: confidence,
-            status: 'pending',
-            createdAt: now,
-            satisfiedAt: null,
-        };
-        created.push({
-            ...partial,
-            spawnHint: buildSpawnHint(partial),
-        });
-    }
-    base.delegations = [
-        ...base.delegations.filter((d) => d.status === 'pending'),
-        ...created,
-    ];
-    if (base.sessionId !== sessionId) {
-        base.sessionId = sessionId;
-        base.createdAt = now;
-        base.delegations = created;
-    }
-    savePendingDelegationsState(base, projectRoot);
-    return created;
-}
-export function isPendingStateActive(state, sessionId) {
-    if (!state)
-        return false;
-    if (!sessionId || state.sessionId !== sessionId)
-        return false;
-    const age = Date.now() - new Date(state.createdAt).getTime();
-    if (age > state.ttlMs)
-        return false;
-    return state.delegations.some((d) => d.status === 'pending');
-}
-export function getActivePendingDelegations(sessionId, projectRoot = process.cwd()) {
-    const state = loadPendingDelegationsState(projectRoot);
-    if (!isPendingStateActive(state, sessionId))
-        return [];
-    return state.delegations.filter((d) => d.status === 'pending');
-}
-export function satisfyDelegation(input, projectRoot = process.cwd()) {
-    const state = loadPendingDelegationsState(projectRoot);
-    if (!state)
-        return { satisfied: [], clearedAll: false };
-    const pending = state.delegations.filter((d) => d.status === 'pending');
-    if (pending.length === 0)
-        return { satisfied: [], clearedAll: false };
-    const prompt = (input.toolPrompt ?? '').toLowerCase();
-    let matches = [];
-    if (input.delegationId) {
-        matches = pending.filter((d) => d.id === input.delegationId);
-    }
-    else if (input.planTodoId) {
-        matches = pending.filter((d) => d.planTodoId === input.planTodoId || prompt.includes(input.planTodoId.toLowerCase()));
-    }
-    else if (input.taskId) {
-        matches = pending.filter((d) => d.taskId === input.taskId || prompt.includes(input.taskId.toLowerCase()));
-    }
-    else if (input.agent) {
-        const norm = normalizeAgent(input.agent);
-        matches = pending.filter((d) => normalizeAgent(d.agent) === norm);
-    }
-    if (matches.length === 0 && prompt) {
-        for (const d of pending) {
-            if (d.planTodoId && prompt.includes(d.planTodoId.toLowerCase())) {
-                matches.push(d);
-                break;
-            }
-            if (prompt.includes(d.taskId.toLowerCase())) {
-                matches.push(d);
-                break;
-            }
-        }
-    }
-    if (matches.length === 0 && pending.length === 1) {
-        const only = pending[0];
-        const hint = only.spawnHint.description.toLowerCase();
-        if (prompt && hint && prompt.includes(hint.slice(0, 40))) {
-            matches = [only];
-        }
-    }
-    if (matches.length === 0) {
-        return { satisfied: [], clearedAll: false };
-    }
-    const now = new Date().toISOString();
-    const matchIds = new Set(matches.map((m) => m.id));
-    for (const d of state.delegations) {
-        if (matchIds.has(d.id) && d.status === 'pending') {
-            d.status = 'satisfied';
-            d.satisfiedAt = now;
-        }
-    }
-    savePendingDelegationsState(state, projectRoot);
-    for (const m of matches) {
-        if (m.planTodoId) {
-            updatePlanTodoStatus(m.planTodoId, 'in_progress', projectRoot);
-        }
-    }
-    const stillPending = state.delegations.some((d) => d.status === 'pending');
-    return { satisfied: matches, clearedAll: !stillPending };
-}
-export function clearPendingDelegations(projectRoot = process.cwd()) {
-    const filePath = pendingDelegationsPath(projectRoot);
-    if (!fs.existsSync(filePath))
-        return false;
-    fs.unlinkSync(filePath);
-    return true;
-}
-export function clearPendingDelegationsForSessionChange(newSessionId, projectRoot = process.cwd()) {
-    const state = loadPendingDelegationsState(projectRoot);
-    if (!state)
-        return false;
-    if (newSessionId && state.sessionId === newSessionId)
-        return false;
-    fs.unlinkSync(pendingDelegationsPath(projectRoot));
-    return true;
-}
-export function delegationSummaryForResponse(delegations) {
-    return delegations.map((d) => ({
-        id: d.id,
-        taskId: d.taskId,
-        agent: d.agent,
-        planTodoId: d.planTodoId,
-        matchMethod: d.matchMethod,
-        matchConfidence: d.matchConfidence,
-        spawnHint: d.spawnHint,
-    }));
-}

package/dist/nucleus/plugin-registry.d.ts

@@ -1,132 +0,0 @@
-/**
- * PluginRegistry — Phase 1.2 dynamic skill loading + Phase 3 generic tool dispatch
- *
- * Allows skills to be registered after boot, loaded from config, or discovered
- * at runtime. Wraps the existing in-process-skill-registry for backward compat.
- *
- * Phase 3 extension: SkillToolPlugin interface for multi-tool skills (knowledge-skill
- * servers). Each server registers as a SkillToolPlugin, exposing arbitrary tools
- * that can be dispatched via callSkillTool().
- *
- * Goals:
- * - New skills can be registered post-boot via register()
- * - Skills are discoverable by name without importing server constructors
- * - Default set loads automatically from the existing 3 governance skills
- * - Multi-tool skills can be registered and dispatched via callSkillTool()
- * - Backward compatible: callInProcessSkill still works as before
- */
-export interface SkillPlugin {
-    /** Unique skill name (e.g. "code-review", "security-audit") */
-    name: string;
-    /** Handler that processes proposals */
-    analyzeProposal(args: SkillProposalArgs): Promise<SkillPluginResult>;
-}
-/**
- * Metadata describing a tool exposed by a SkillToolPlugin.
- */
-export interface ToolDefinition {
-    name: string;
-    description: string;
-    inputSchema?: Record<string, unknown>;
-}
-/**
- * Extended plugin interface for knowledge-skill servers that expose multiple tools.
- * Each tool is a named function that accepts arbitrary args.
- */
-export interface SkillToolPlugin {
-    /** Unique skill name (e.g. "code-review", "api-design") */
-    name: string;
-    /** Dispatch a named tool with arbitrary args */
-    callTool(toolName: string, args: Record<string, unknown>): Promise<unknown>;
-    /** Optional: list tool definitions for dynamic discovery */
-    listTools?(): ToolDefinition[];
-}
-export interface SkillProposalArgs {
-    proposalTitle?: string;
-    proposalDescription?: string;
-    evidence?: string[];
-    proposalType?: string;
-}
-export interface SkillPluginResult {
-    content: Array<{
-        type: string;
-        text: string;
-    }>;
-}
-type SkillHandler = (args: SkillProposalArgs) => Promise<SkillPluginResult>;
-declare class PluginRegistryImpl {
-    private skills;
-    /** Phase 3: multi-tool skill plugins (knowledge-skill servers) */
-    private toolPlugins;
-    private initialized;
-    /**
-     * Register a skill plugin. Can be called after boot.
-     */
-    register(skill: SkillPlugin): void;
-    /**
-     * Register a multi-tool skill plugin (knowledge-skill server).
-     * Tools can be dispatched via callSkillTool().
-     */
-    registerToolPlugin(skill: SkillToolPlugin): void;
-    /**
-     * Call a named tool on a registered multi-tool skill plugin.
-     */
-    callSkillTool(skillName: string, toolName: string, args: Record<string, unknown>): Promise<unknown>;
-    /**
-     * Check if a tool plugin is registered.
-     */
-    hasToolPlugin(name: string): boolean;
-    /**
-     * List all registered tool plugin names.
-     */
-    listToolPlugins(): string[];
-    /**
-     * Get a registered tool plugin by name for introspection.
-     */
-    getToolPlugin(name: string): SkillToolPlugin | undefined;
-    /**
-     * List tool definitions for a registered tool plugin.
-     * Returns empty array if plugin not found or does not expose listTools().
-     */
-    listSkillTools(skillName: string): ToolDefinition[];
-    /**
-     * Convenience: register a server as a SkillToolPlugin.
-     * Wraps a server with named tools into the SkillToolPlugin interface.
-     */
-    registerServer(server: {
-        name: string;
-        tools: ToolDefinition[];
-        callTool: (toolName: string, args: Record<string, unknown>) => Promise<unknown>;
-    }): void;
-    /**
-     * Get a skill handler by name. Falls back to the in-process registry
-     * for the built-in governance skills (code-review, security-audit, researcher).
-     */
-    get(name: string): SkillHandler | undefined;
-    /**
-     * Check if a skill is registered (either in the plugin registry or the built-in registry).
-     */
-    has(name: string): boolean;
-    /**
-     * List all registered skill names (plugins + built-in).
-     */
-    list(): string[];
-    /**
-     * Call a skill by name. Delegates to the plugin registry first,
-     * then falls back to the built-in in-process registry.
-     */
-    callSkill(name: string, args: SkillProposalArgs): Promise<SkillPluginResult>;
-    /**
-     * Initialize with default governance skills. Called once at boot.
-     * The 3 governance skills are always available via the built-in registry.
-     */
-    initializeDefaults(): void;
-    /**
-     * Reset the registry for testing. Removes all registered plugins
-     * (built-in governance skills remain available via fallback).
-     */
-    resetForTest(): void;
-}
-/** Singleton plugin registry */
-export declare const pluginRegistry: PluginRegistryImpl;
-export {};

package/dist/nucleus/plugin-registry.js

@@ -1,175 +0,0 @@
-/**
- * PluginRegistry — Phase 1.2 dynamic skill loading + Phase 3 generic tool dispatch
- *
- * Allows skills to be registered after boot, loaded from config, or discovered
- * at runtime. Wraps the existing in-process-skill-registry for backward compat.
- *
- * Phase 3 extension: SkillToolPlugin interface for multi-tool skills (knowledge-skill
- * servers). Each server registers as a SkillToolPlugin, exposing arbitrary tools
- * that can be dispatched via callSkillTool().
- *
- * Goals:
- * - New skills can be registered post-boot via register()
- * - Skills are discoverable by name without importing server constructors
- * - Default set loads automatically from the existing 3 governance skills
- * - Multi-tool skills can be registered and dispatched via callSkillTool()
- * - Backward compatible: callInProcessSkill still works as before
- */
-import { callInProcessSkill } from '../mcps/in-process-skill-registry.js';
-import { frameworkLogger } from '../core/framework-logger.js';
-class PluginRegistryImpl {
-    skills = new Map();
-    /** Phase 3: multi-tool skill plugins (knowledge-skill servers) */
-    toolPlugins = new Map();
-    initialized = false;
-    /**
-     * Register a skill plugin. Can be called after boot.
-     */
-    register(skill) {
-        if (this.skills.has(skill.name)) {
-            frameworkLogger.log('plugin-registry', 'register-overwrite', 'warning', {
-                skillName: skill.name,
-                message: 'Overwriting existing skill registration',
-            });
-        }
-        this.skills.set(skill.name, (args) => skill.analyzeProposal(args));
-        frameworkLogger.log('plugin-registry', 'register', 'info', {
-            skillName: skill.name,
-            totalSkills: this.skills.size,
-        });
-    }
-    /**
-     * Register a multi-tool skill plugin (knowledge-skill server).
-     * Tools can be dispatched via callSkillTool().
-     */
-    registerToolPlugin(skill) {
-        if (this.toolPlugins.has(skill.name)) {
-            frameworkLogger.log('plugin-registry', 'register-tool-overwrite', 'warning', {
-                skillName: skill.name,
-                message: 'Overwriting existing tool plugin registration',
-            });
-        }
-        this.toolPlugins.set(skill.name, skill);
-        frameworkLogger.log('plugin-registry', 'register-tool', 'info', {
-            skillName: skill.name,
-            totalToolPlugins: this.toolPlugins.size,
-        });
-    }
-    /**
-     * Call a named tool on a registered multi-tool skill plugin.
-     */
-    async callSkillTool(skillName, toolName, args) {
-        const plugin = this.toolPlugins.get(skillName);
-        if (!plugin) {
-            throw new Error(`No tool plugin registered: ${skillName}. Available: ${Array.from(this.toolPlugins.keys()).join(', ')}`);
-        }
-        return plugin.callTool(toolName, args);
-    }
-    /**
-     * Check if a tool plugin is registered.
-     */
-    hasToolPlugin(name) {
-        return this.toolPlugins.has(name);
-    }
-    /**
-     * List all registered tool plugin names.
-     */
-    listToolPlugins() {
-        return Array.from(this.toolPlugins.keys());
-    }
-    /**
-     * Get a registered tool plugin by name for introspection.
-     */
-    getToolPlugin(name) {
-        return this.toolPlugins.get(name);
-    }
-    /**
-     * List tool definitions for a registered tool plugin.
-     * Returns empty array if plugin not found or does not expose listTools().
-     */
-    listSkillTools(skillName) {
-        const plugin = this.toolPlugins.get(skillName);
-        if (!plugin || !plugin.listTools)
-            return [];
-        return plugin.listTools();
-    }
-    /**
-     * Convenience: register a server as a SkillToolPlugin.
-     * Wraps a server with named tools into the SkillToolPlugin interface.
-     */
-    registerServer(server) {
-        const plugin = {
-            name: server.name,
-            callTool: server.callTool,
-            listTools: () => server.tools,
-        };
-        this.registerToolPlugin(plugin);
-    }
-    /**
-     * Get a skill handler by name. Falls back to the in-process registry
-     * for the built-in governance skills (code-review, security-audit, researcher).
-     */
-    get(name) {
-        const handler = this.skills.get(name);
-        if (handler)
-            return handler;
-        // Fall back to the built-in registry for the 3 governance skills
-        const builtInNames = ['code-review', 'security-audit', 'researcher'];
-        if (builtInNames.includes(name)) {
-            return async (args) => {
-                const result = await callInProcessSkill(name, 'analyze_proposal', args);
-                return result;
-            };
-        }
-        return undefined;
-    }
-    /**
-     * Check if a skill is registered (either in the plugin registry or the built-in registry).
-     */
-    has(name) {
-        return this.skills.has(name) || ['code-review', 'security-audit', 'researcher'].includes(name);
-    }
-    /**
-     * List all registered skill names (plugins + built-in).
-     */
-    list() {
-        const builtIn = ['code-review', 'security-audit', 'researcher'];
-        const pluginNames = Array.from(this.skills.keys());
-        return [...new Set([...builtIn, ...pluginNames])];
-    }
-    /**
-     * Call a skill by name. Delegates to the plugin registry first,
-     * then falls back to the built-in in-process registry.
-     */
-    async callSkill(name, args) {
-        const handler = this.get(name);
-        if (!handler) {
-            throw new Error(`No skill registered: ${name}. Available: ${this.list().join(', ')}`);
-        }
-        return handler(args);
-    }
-    /**
-     * Initialize with default governance skills. Called once at boot.
-     * The 3 governance skills are always available via the built-in registry.
-     */
-    initializeDefaults() {
-        if (this.initialized)
-            return;
-        this.initialized = true;
-        frameworkLogger.log('plugin-registry', 'initialize-defaults', 'info', {
-            builtInSkills: ['code-review', 'security-audit', 'researcher'],
-            message: 'Default governance skills available via built-in registry',
-        });
-    }
-    /**
-     * Reset the registry for testing. Removes all registered plugins
-     * (built-in governance skills remain available via fallback).
-     */
-    resetForTest() {
-        this.skills.clear();
-        this.toolPlugins.clear();
-        this.initialized = false;
-    }
-}
-/** Singleton plugin registry */
-export const pluginRegistry = new PluginRegistryImpl();

package/dist/nucleus/spawn-plan-resolution.d.ts

@@ -1,20 +0,0 @@
-/**
- * Spawn plan resolution SSOT — main lead-dev plan vs active user aside.
- * Extracted to avoid circular imports between user-aside and lead-dev-plan-persistence.
- */
-import { type PersistedLeadDevPlan } from './lead-dev-plan-persistence.js';
-export interface SpawnPlanResolution {
-    source: 'main' | 'aside' | 'none';
-    asideId?: string;
-    plan: PersistedLeadDevPlan | null;
-    worktree?: string;
-    branch?: string;
-}
-export interface SpawnPlanToolInput {
-    planTodoId?: string;
-    prompt?: string;
-    description?: string;
-    task?: string;
-}
-export declare function resolveSpawnPlan(toolInput: SpawnPlanToolInput, projectRoot?: string, sessionId?: string | null): SpawnPlanResolution;
-export declare function hasValidSpawnPlanContext(projectRoot?: string, sessionId?: string | null): boolean;

package/dist/nucleus/spawn-plan-resolution.js

@@ -1,42 +0,0 @@
-/**
- * Spawn plan resolution SSOT — main lead-dev plan vs active user aside.
- * Extracted to avoid circular imports between user-aside and lead-dev-plan-persistence.
- */
-import { getOutstandingTodos, hasValidLeadDevPlanForSpawn, loadPersistedLeadDevPlan, } from './lead-dev-plan-persistence.js';
-import { asideToSpawnPlan, findAsideContainingTodo, isAsideActiveForSession, isUserAsideTodoId, isUserAsidesEnabled, loadActiveUserAside, parseAsideIdFromTodoId, } from './user-aside.js';
-export function resolveSpawnPlan(toolInput, projectRoot = process.cwd(), sessionId) {
-    const explicitTodo = toolInput.planTodoId;
-    if (explicitTodo && isUserAsideTodoId(explicitTodo)) {
-        const parsedAsideId = parseAsideIdFromTodoId(explicitTodo);
-        const aside = findAsideContainingTodo(explicitTodo, projectRoot, parsedAsideId ?? undefined);
-        if (aside && isAsideActiveForSession(aside.id, projectRoot, sessionId)) {
-            return asideResolution(aside);
-        }
-    }
-    const active = loadActiveUserAside(projectRoot, sessionId);
-    if (active) {
-        return asideResolution(active);
-    }
-    const main = loadPersistedLeadDevPlan(projectRoot);
-    if (main?.active) {
-        return { source: 'main', plan: main };
-    }
-    return { source: 'none', plan: null };
-}
-function asideResolution(aside) {
-    return {
-        source: 'aside',
-        asideId: aside.id,
-        plan: asideToSpawnPlan(aside),
-        ...(aside.worktree ? { worktree: aside.worktree } : {}),
-        ...(aside.branch ? { branch: aside.branch } : {}),
-    };
-}
-export function hasValidSpawnPlanContext(projectRoot = process.cwd(), sessionId) {
-    const active = loadActiveUserAside(projectRoot, sessionId);
-    if (active && isUserAsidesEnabled(projectRoot)) {
-        const plan = asideToSpawnPlan(active);
-        return getOutstandingTodos(plan).length > 0 || plan.active;
-    }
-    return hasValidLeadDevPlanForSpawn(projectRoot, sessionId);
-}