0xray 4.0.13 → 4.0.14

package/dist/nucleus/pending-delegations.js

@@ -0,0 +1,285 @@
+/**
+ * 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

@@ -0,0 +1,132 @@
+/**
+ * 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

@@ -0,0 +1,175 @@
+/**
+ * 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

@@ -0,0 +1,20 @@
+/**
+ * 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

@@ -0,0 +1,42 @@
+/**
+ * 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);
+}